a:85:{s:14:"__file_content";s:19:"alb-saved-templates";s:6:"01test";s:578:"[av_portfolio categories='54' term_rel='' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' period_filter_unit_1='1' period_filter_unit_2='year' page_element_filter='' sort='no' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']";s:11:"03-handouts";s:18972:"[av_tab_section transition='av-tab-slide-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' av_element_hidden_in_editor='0' av_admin_tab_active='2' bg_color='#828282' color='#f9f9f9' id='' custom_class='' aria_label='' av_uid='']
[av_tab_sub_section tab_title='Watch Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">IE11 Support is Ending Soon! Replace your Legacy 3270 Emulator with a Modern Solution</h3>
<p style="text-align: center;">March 10, 2022</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_video src='https://vimeo.com/686804235' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Handouts' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_masonry_gallery ids='22338,2600,10321' caption_elements='title excerpt' caption_styling='' caption_display='always' size='flex' orientation='' image_size='no scaling' gap='large' columns='flexible' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='' custom_bg='' overlay_fx='active' animation='active' container_links='' link_dest='_blank' lightbox_text='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section][av_tab_sub_section tab_title='Webinar Details' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4>Modern and Secure Mainframe Access with Virtel</h4>
This 30-minute webinar provides a high-level overview of Virtel Web Access and its benefits.

<b class="black">This presentation will cover the following topics:</b>
<ul>
 	<li>Summarize the 3270 implications related to IE11 support ending on June 15, 2022</li>
 	<li>Describe benefits associated with a thin-client, browser-based 3270 terminal emulator</li>
 	<li>Explore how replacing your legacy 3270 emulator with Virtel will improve security while providing significant cost savings</li>
</ul>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='_blank' size='large' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-2543' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='1' border_color='#acacac' radius='0px' radius_sync='true' padding='20px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h5 class="nocaps" style="text-align: center;">Virtel Web Access</h5>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_bg='#525252' custom_font='' custom_border='' animation='' alb_description='' id='' custom_class='' av_uid='' admin_preview_bg='']
[av_iconlist_item title='Replace your 3270 Terminal Emulator and Save up to 80%' icon='ue86c' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Ultra-Thin Client Architecture promotes Security, Mobility, Flexibility' icon='ue8ab' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Serve 3270 Screens on Browser over Encrypted HTTPS Connections' icon='ue824' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='End Dependence on Unsafe Applets and Plugins: Java plugin is NOT used' icon='ue8b9' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Simplify Support Needs and Lower Costs across the board' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Abstract</h3>
Does your organization rely on plugin-dependent solutions for your 3270 emulation?  With support for IE11 ending on June 15, 2022, now is the time to find a replacement solution.  Choosing a thin-client, browser-based 3270 emulator like Virtel Web Access will benefit your organization in a number of ways.

<strong>During this 30-minute webinar, we will:
</strong>
<ul>
 	<li>Summarize the 3270 implications related to IE11 support ending on June 15, 2022</li>
 	<li>Describe benefits associated with a thin-client, browser-based 3270 terminal emulator</li>
 	<li>Explore how replacing your legacy 3270 emulator with Virtel will improve security while providing significant cost savings</li>
</ul>

<hr />

This webinar is sponsored by Software Diversified Services (SDS) in partnership with SysperTec.
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='VWA Intro Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Introduction Videos</h3>
<h4 class="nocaps" style="text-align: center;">Virtel Web Access</h4>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0px' custom_margin_bottom='0px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='30px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_video src='https://vimeo.com/album/4422954' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' av_uid='']

[/av_three_fifth][av_one_fifth min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px,5px,0px,0px' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_portfolio categories='57' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' sort='no' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' lazy_loading='disabled' id='' custom_class='' av_uid='']

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]";s:24:"08-23-cafc-pr-for-vsa-43";s:18227:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h1 class="secondary">CAFC 6.1.00 Available for Day One Support of CICS/TS 6.1</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='20' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">June 17, 2022</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' id='' custom_class='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='small' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_fifth first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<em><a href="/cics-management/cafc/">CAFC</a>, an SDS CICS Management Product, offers Day One Support for CICS/TS 6.1.</em>
<p style="text-align: right;">Lori Kettles, 763-571-9000, <a href="mailto:info@sdsusa.com?subject=CAFC61PR" target="_blank" rel="noopener">info@sdsusa.com</a></p>
<b class="black">MINNEAPOLIS, MN – June 17, 2022</b> – Software Diversified Services (SDS) is very pleased to announce a maintenance release for CICS Application File Control, CAFC 6.1.00 MAINT001, is now available to download.

This maintenance release fulfills customers' expectations of SDS offering day one support for IBM CICS Transaction Server for z/OS, CICS/TS 6.1, which became Generally Available today, June 17, 2022.  It also extends the streak of offering day one support for each new version of CICS/TS, dating back to the SDS acquisition of CAFC in 2016.

<hr />

<h4 class="nocaps">What’s new in CAFC 6.1.00 MAINT001?</h4>
<ul>
 	<li>Support for CICS/TS 5.4 through 6.1</li>
 	<li>Several new requested features became available with the release of CAFC 6.1.00
<ul>
 	<li>View highlights at our previous <a href="https://sdsusastg.wpenginepowered.com/blog/news/cafc-6-1-00-is-ga-new-features-and-cics-ts-6-1-support/">blog post announcing the release of CAFC 6.1.00</a></li>
 	<li>For a complete list of enhancements and fixes, please see the What’s New PDF, which is available in the documentation zip file at the <a href="https://support.sdsusa.com/downloads/" target="_blank" rel="noopener">SDS downloads webpage</a>.</li>
</ul>
</li>
</ul>

<hr />

<h4 class="nocaps">CAFC Customer Notes</h4>
<ul>
 	<li>To download CAFC 6.1.00 MAINT001, you will need a CAFC 6.1.00 access key. Please <a href="https://support.sdsusa.com/issues/">contact support</a> if your team needs a CAFC 6.1.00 download access key.</li>
 	<li>With the release of CAFC 6.1.00 back in March, we scheduled the CAFC 5.5.00 End of Service date for March 30, 2023.</li>
 	<li class="nocaps"><strong>Unsure which CAFC version is compatible with your version of CICS/TS?</strong>
<ul>
 	<li>Please take a look at the updated CAFC-CICS matrix below if you’re unsure which version(s) of CAFC will work with your CICS/TS level, z/OS level, or IBM Processor.</li>
 	<li>If you’d like to run the new CICS/TS 6.1, please download CAFC 6.1.00 MAINT001.</li>
</ul>
</li>
</ul>
<img src="https://support.sdsusa.com/_images/cafc-cics-version-matrix.png" />
<h4 class="nocaps">Thank you for using CAFC,</h4>
<h3 class="nocaps">The Entire SDS Team</h3>

<hr />
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/SDS-logo-quality-mainframe.png' attachment='10979' attachment_size='full' align='center' styling='no-styling' hover='' link='page,11' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
Founded in 1982, Software Diversified Services delivers comprehensive, affordable mainframe and distributed software with a focus on cybersecurity and compliance. Hundreds of organizations worldwide, including many Fortune 500 companies, rely on SDS software. Our expert development and award-winning technical support teams are based in Minneapolis, MN. To learn more, please visit <a href="https://sdsusastg.wpenginepowered.com">sdsusastg.wpenginepowered.com</a>.
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-2116' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:24:"0224-app-acc-cat-section";s:7520:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='av-break-at-tablet' av_uid='' custom_class='']

[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-cics.png' attachment='374' attachment_size='full' align='center' styling='no-styling' hover='' link='page,99' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/application-access-modernization/">Application Access & Modernization</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<table class="e8e8e8gray3">
<tbody>
<tr>
<td><a href="/application-access-modernization/virtel-web-access/">Virtel<sup>®</sup> Web Access</a></td>
<td>Ultra-thin and secure 3270 TE on any device</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-web-modernization/">Virtel<sup>®</sup> Web Modernization</a></td>
<td>Serve host transactions as user-friendly web pages (GUIs)</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-web-integration/">Virtel<sup>®</sup> Web Integration</a></td>
<td>Create interactive bidirectional connections; integrate host &amp; web</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-screen-redesigner/">Virtel<sup>®</sup> Screen Redesigner</a></td>
<td>Create modern and user-friendly web UIs from your existing legacy 3270 screens</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#cacaca' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-application-access.png' attachment='375' attachment_size='full' align='center' styling='no-styling' hover='' link='page,101' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/cics-management/">CICS Management</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="cacacagray3">
<tbody>
<tr>
<td><a href="/cics-management/cafc/">CAFC<sup>™</sup></a></td>
<td>CICS Application File Control system software</td>
</tr>
<tr>
<td><a href="/cics-management/ipcp-plus/">IPCP<sup>™</sup> Plus for z/OS & z/VSE</a></td>
<td>Premier file control utility for z/OS & z/VSE</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#f7f7f7' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-security.png' attachment='371' attachment_size='full' align='center' styling='no-styling' hover='' link='page,16088' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='fade-in' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_textblock size='' font_color='custom' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/encryption-ssh-solutions/">Encryption & SSH Solutions</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<table class="f7f7f7gray3">
<tbody>
<tr>
<td><a href="/security-software/e-business-server/">SDS E-Business Server<sup>®</sup></a></td>
<td>Multi-platform PGP encryption for data at rest</td>
</tr>
<tr>
<td><a href="/security-software/tectia-ssh/">Tectia<sup>®</sup> SSH</a></td>
<td>Server and client that secures and encrypts file transfers and more</td>
</tr>
<tr>
<td><a href="/security-software/universal-ssh-key-manager/">Universal SSH Key Manager<sup>®</sup></a></td>
<td>Centralize, simplify, and automate SSH key management</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][/av_layout_row]";s:17:"0224-vsr-bb-after";s:5724:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/coding-gray-right.jpg' attachment='23142' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Green Screen No More! Tracking a Customer’s Path to Modern Web UIs</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Watch this 30-minute webinar now.  We'll explore Virtel Screen Redesigner and how it can help your organization modernize your 3270 screens.</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23209' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]";s:26:"0224-vsr-webinar-bb-normal";s:5732:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/coding-gray-right.jpg' attachment='23142' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description" style="text-align: center;">Green Screen No More! Tracking a Customer’s Path to Modern Web UIs</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us as we look into a recent customer success story.  Register now for this 30-minute webinar on Wednesday, February 28 at 1:00PM CT.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23209' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:17:"0224-vwa-web-tabs";s:28578:"[av_tab_section transition='av-tab-slide-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' av_element_hidden_in_editor='0' av_admin_tab_active='1' bg_color='#828282' color='#f9f9f9' id='' custom_class='' aria_label='' av_uid='']
[av_tab_sub_section tab_title='Past Webinars' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' mobile_column_order='' min_col_height='' padding='30px,0px,0px,0px' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/webinar/ie11-support-is-ending-replace-your-3270-emulator-now//">IE11 Support is Ending Soon! Replace your Legacy 3270 Emulator with a Modern Solution</a></h3>
<p style="text-align: center;">Our latest Virtel Web Access webinar from March 10, 2022 is available <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/webinar/ie11-support-is-ending-replace-your-3270-emulator-now//">here</a>.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px,10px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vwa-webinar-page-031022.jpg' attachment='22355' attachment_size='full' copyright='' caption='' image_size='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,22334' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px,10px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#7f7f7f' custom_icon_color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' mobile_column_order='' min_col_height='' padding='30px,0px,0px,0px' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/webinar/replace-your-tn3270-emulator-and-session-manager-with-vwa/">Replace both your TN3270 Emulator and Session Manager with a Single Product: Virtel Web Access</a></h3>
<p style="text-align: center;">This Virtel Web Access webinar from May 26, 2021 is available <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/webinar/replace-your-tn3270-emulator-and-session-manager-with-vwa/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px,10px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vwa-webinar-page-0521.png' attachment='21411' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,21389' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px,10px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#7f7f7f' custom_icon_color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/webinar/more-secure-3270-te-solution-for-future/">Migrate to a More Secure and Manageable 3270 TE Solution for the Future</a></h3>
<p style="text-align: center;">Our Virtel Web Access webinar from October 29, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/webinar/more-secure-3270-te-solution-for-future/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px,10px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vwa-webinar-page-1020.png' attachment='20623' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,20493' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px,10px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#7f7f7f' custom_icon_color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/webinar/working-from-home-with-secure-3270-te/">Working from Home</a></h3>
<h4 class="nocaps" style="text-align: center;">Using Virtel's Browser-Based 3270 Terminal Emulation</h4>
<p style="text-align: center;">Our Virtel Web Access webinar from April 8, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/webinar/working-from-home-with-secure-3270-te/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vwa-webinar-page-042020.jpg' attachment='20788' attachment_size='full' copyright='' caption='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,18938' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#7f7f7f' custom_icon_color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Business Digital Transformation</h3>
<h4 class="nocaps" style="text-align: center;">Continue Using Mainframe Applications with a Practical Approach</h4>
<p style="text-align: center;">This is our latest <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-webinar/">Virtel Web Suite webinar</a> - May 16, 2019.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/336872664' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Intro Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Introduction Videos</h3>
<h4 class="nocaps" style="text-align: center;">Virtel Web Access</h4>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0px' custom_margin_bottom='0px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='30px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_video src='https://vimeo.com/album/4422954' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' av_uid='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
If your browser failed to open the Virtel Web Access Datasheet (opens in a new tab usually), <a href="https://sdsusastg.wpenginepowered.com/productdocs/VWA-datasheet.pdf">please click here</a>.
[/av_textblock]

[/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_portfolio categories='57' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' sort='no' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' lazy_loading='disabled' id='' custom_class='' av_uid='']

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]";s:25:"0224-zos-category-section";s:7879:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='av-break-at-tablet' av_uid='' custom_class='']

[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#f7f7f7' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-security-compliance.png' attachment='16085' attachment_size='full' align='center' styling='no-styling' hover='' link='page,15555' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='fade-in' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_textblock size='' font_color='custom' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/mainframe-security-compliance/"><span class="lower">z</span>/OS Security & Compliance</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<table class="f7f7f7gray3">
<tbody>
<tr>
<td><a href="/security-software/mainframe-siem/">VitalSigns SIEM Agent<sup>™</sup> for z/OS</a></td>
<td>Integrate mainframe security events into any enterprise SIEM</td>
</tr>
<tr>
<td><a href="/security-software/vst/">VitalSigns for Secure Transfer<sup>™</sup></a></td>
<td>Automatic Secure Outbound Mainframe FTP Sessions</td>
</tr>
<tr>
<td><a href="/security-software/vftp-ssh/">VFTP-SSH Collaboration</a></td>
<td>Complete FTP security for z/OS; no JCL changes needed</td>
</tr>
<tr>
<td><a href="/security-software/e-business-server/">SDS E-Business Server<sup>®</sup> for z/OS</a></td>
<td>Rock-solid PGP encryption for data at rest</td>
</tr>
<tr>
<td><a href="/security-software/automatic-mainframe-stig-monitoring/">SDS IronSphere for z/OS</a></td>
<td>Automated DISA STIG compliance monitoring for z/OS</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-network.png' attachment='372' attachment_size='full' align='center' styling='no-styling' hover='' link='page,95' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/mainframe-network-management/">Mainframe Network Management</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="e8e8e8gray3">
<tbody>
<tr>
<td><a href="/mainframe-network-management/vftp/">VitalSigns for FTP<sup>™</sup></a></td>
<td>Snap-in security for file transfers to & from z/OS</td>
</tr>
<tr>
<td><a href="/mainframe-network-management/vip/">VitalSigns for IP<sup>™</sup></a></td>
<td>Complete IP monitoring on z/OS</td>
</tr>
<tr>
<td><a href="/mainframe-network-management/vnac/">VitalSigns for NAC<sup>™</sup></a></td>
<td>Replace legacy mainframe network monitoring</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#cacaca' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-performance.png' attachment='373' attachment_size='full' align='center' styling='no-styling' hover='' link='page,97' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/mainframe-performance-optimization/">Mainframe Performance & Optimization</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<table class="cacacagray3">
<tbody>
<tr>
<td><a href="/mainframe-performance-optimization/conicit/">ConicIT<sup>®</sup></a></td>
<td>Predictive operations management and analysis for z/OS</td>
</tr>
<tr>
<td><a href="/mainframe-performance-optimization/cloud-compiling-zos/">Cloud Compiling for z/OS</a></td>
<td>Reduce compiling redundancies and save 50% guaranteed</td>
</tr>
<tr>
<td><a href="/mainframe-performance-optimization/multiterm/">Multiterm<sup>™</sup> for z/OS, z/VM, & z/VSE</a></td>
<td>Premier session manager for z Series mainframes</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][/av_layout_row]";s:14:"0322-news-post";s:19261:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h1 class="secondary">CAFC 6.1.00 is G.A. - New Features and CICS/TS 6.1 Support</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">March 31, 2022</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='small' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_fifth first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<em>SDS releases a new version of its CICS Management Product, <a href="/cics-management/cafc/">CAFC</a> 6.1.00. This new CICS/TS 6.1-compatible version of CAFC also contains numerous new features and capabilities.
</em>
<p style="text-align: right;">Lori Kettles, 763-571-9000, <a href="mailto:info@sdsusa.com?subject=CAFC56PR" target="_blank" rel="noopener">info@sdsusa.com</a></p>
<b class="black">MINNEAPOLIS, MN – March 31, 2022</b> – Software Diversified Services (SDS) is very pleased to announce a new release of CICS Application File Control, CAFC 6.1.00, is Generally Available.

This will accomplish your expectations of SDS offering day one support for IBM CICS Transaction Server for z/OS, CICS/TS 6.1, when it becomes Generally Available (currently scheduled for June 17, 2022).

CAFC 6.1.00 also provides additional functionality and new features. These enhancements were requested by CAFC users and implemented by the SDS CICS development team.

<hr />

<h4 class="nocaps">Highlights of the CAFC 6.1.00 Release</h4>
<ul>
 	<li>Support for CICS Transaction Server 5.4 through 6.1.</li>
 	<li>In the SET_CICS command, the APPLID can now use a generic CICS name with wildcards.</li>
 	<li>Improved RACF security functionality, including the generation of SMF 80 records on successful and failed access attempts and improved handling of ICH408I messages. Samples to create RACF classes and profiles are also now included in INSTALL member @I90INST.</li>
 	<li>Improvements to the CAFC batch interface:
<ul>
 	<li>The addition of an option to run the CAFC batch interface APF authorized. This will allow more targeted SMF 80 records to be produced when security checks are performed against resource access attempts.</li>
 	<li>Added the ability to optionally check OPER profiles as part of RACF security checks.</li>
 	<li>Improved handling of failed LU6.2 connections when executing multiple CAFC commands via the batch interface.</li>
 	<li>Added the ability to enable and disable all CAFC trace destinations.</li>
</ul>
</li>
 	<li>Improved security handling for CAFC online reports.</li>
 	<li>Serviceability improvements:
<ul>
 	<li>Improvements in trace output printing to help reduce the size of trace output.</li>
 	<li>Improvements to trace output to correctly print lower case characters.</li>
 	<li>CAFC batch will now automatically turn on tracing to the CAFCTRAC DD when no trace outputs have been previously selected.</li>
</ul>
</li>
</ul>

<hr />

<h4 class="nocaps">CAFC Customer Notes</h4>
<ul>
 	<li>To download CAFC 6.1.00, you will need an updated access key. Please <a href="https://support.sdsusa.com/issues/">contact support</a> in order to receive a new CAFC download access key.</li>
 	<li>For a complete list of enhancements and fixes, please see the What’s New PDF, which is available once you're logged into the <a href="https://support.sdsusa.com/downloads/" target="_blank" rel="noopener">SDS downloads webpage</a>.</li>
 	<li class="nocaps"><strong>Unsure which CAFC version is compatible with your version of CICS/TS?</strong>
<ul>
 	<li>Please take a look at the updated CAFC-CICS matrix below if you're unsure which version(s) of CAFC will work with your CICS/TS level, z/OS level, or IBM Processor.</li>
 	<li>If you'd like to run the new CICS/TS 6.1 once it's G.A., please download CAFC 6.1.00.</li>
</ul>
</li>
 	<li>With the release of CAFC 6.1.00, we have scheduled the CAFC 5.5.00 End of Service date for March 30, 2022.</li>
</ul>
<img src="https://support.sdsusa.com/_images/cafc-cics-version-matrix.png" />
<h4 class="nocaps">Thank you for using CAFC,</h4>
<h3 class="nocaps">The Entire SDS Team</h3>

<hr />
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/SDS-logo-quality-mainframe.png' attachment='10979' attachment_size='full' align='center' styling='no-styling' hover='' link='page,11' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
Founded in 1982, Software Diversified Services delivers comprehensive, affordable mainframe and distributed software with a focus on cybersecurity and compliance. Hundreds of organizations worldwide, including many Fortune 500 companies, rely on SDS software. Our expert development and award-winning technical support teams are based in Minneapolis, MN. To learn more, please visit <a href="https://sdsusastg.wpenginepowered.com">sdsusastg.wpenginepowered.com</a>.
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#525252' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#525252' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>

[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-2543' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:22:"0323-iron-web-bb-after";s:5011:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Automatic STIG Compliance Monitoring for z/OS and iSeries with One Tool</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Watch as the founder of IronSphere, Itschak Mugzach, explains the current need for an automatic STIG compliance monitoring tool for z/OS and iSeries. A brief demo of IronSphere in action will also be provided.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,22943' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:27:"0323-ironsphere-bb-upcoming";s:5100:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Automatic STIG Compliance Monitoring for z/OS and iSeries with One Tool</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Watch as the founder of IronSphere, Itschak Mugzach, explains the current need for an automatic STIG compliance monitoring tool for z/OS and iSeries. A brief demo of IronSphere in action will also be provided</p>
<p style="text-align: center;"><strong>Wednesday, March 15, 2023 at 1:00PM CT</strong></p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,8303' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]";s:32:"0422-iron-after-bb-content-right";s:3706:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Automatic, Security Standards-based Monitoring with IronSphere for z/OS</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Thank you to those who joined us for this webinar.  During the webinar, the creator of IronSphere for z/OS provided a product overview along with a demonstration.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,8303' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:14:"0423-blog-post";s:15172:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h1 class="secondary">TN3270, 3270 terminal, 3270 applications… What is 3270?</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='20' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">July 18, 2022</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' id='' custom_class='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='small' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_full first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
Everyone knows what 3270 means, right?  Sure, within the mainframe community, 3270 is a common term, but what about those non-mainframers out there?  3270 is used to describe quite of lot of things related to accessing the mainframe: 3270 terminals, 3270 applications, 3270 protocols, and TN3270 emulators.  In this post, we will try to provide some relevant information that will help everyone better understand 3270 and the related terms.
<h4 class="nocaps">3270 Mainframe Terminal: History</h4>
The original IBM 3270 mainframe terminal was released in 1971 to replace its predecessor, the IBM 2260. Consisting of a screen and a keyboard, the 3270 was a non-programmable terminal and was meant to be used in conjunction with a centralized mainframe.  This was happening over the limited bandwidth networks at that time. Because of it was a non-programmable workstation, the 3270 was often called a “dumb” workstation.

Companies adopted 3270 terminals in large numbers. Indeed, in the ‘70s and ‘80s, most large companies throughout the world were using an IBM mainframe computer, often running CICS or some other competing software application. Typically, the organization would then utilize 3270 terminals to connect with the mainframe.

Early on, an IBM 3270 mainframe terminal consisted of only a few components: a big CRT (Cathode Ray Tube) monitor, a keyboard, and a coaxial cable which connected the terminal to the mainframe by way of a control unit. Amazingly, with only 16MB of memory, an IBM 3033 mainframe from the 1970s could support up to 17,500 3270 terminals under a single CICS application!

Each of the 3270 terminals were communicating with the mainframe using the "3270 data stream" language. The goal of the language was to maximize the number of terminals that could be used from a single mainframe without frequent interruptions.

Nowadays, the 3270 mainframe terminals have disappeared from companies and have been replaced by PCs for the most part.  However, the 3270 data stream language is still being used, interpreted by various kinds of<a href="https://blog.virtelweb.com/what-is-the-best-alternative-to-replace-your-existing-terminal-emulation"> 3270 emulators</a><strong>. </strong>
<h4 class="nocaps">3270 Mainframe Applications</h4>
Also known as green screen applications, 3270 mainframe applications are accessible through 3270 terminals or TN3270 emulators. The most well-known of the building-block applications are:

<strong>Conversational Monitor System (CMS) </strong>is a simple and interactive, single-user operating system. CMS runs as a “guest” operating system inside of a private virtual machine.  The user typically logs onto VM first, then enters the command ‘i cms.’  The VM control program and CMS together create a multi-user time-sharing operating system.

<strong>Time Sharing Option (TMO)</strong> is an interactive time-sharing environment for IBM mainframe operating systems (i.e., z/OS).  This allows many users to use the system concurrently without interfering with each other. This is achieved mainly through TSO’s single login capability (unique ID and password for each user). Once logged in, users can use ISPF (Interactive System Productivity Facility) to interact with the mainframe.

<strong>Customer Information Control System (CICS)</strong> is a family of mixed-language application servers that allow millions of transactions to be processed everyday all around the world. The CICS Transaction Server (CICS/TS) is the most important part of the CICS family and it provides online transaction management and connectivity for applications on IBM mainframes.

You’ll find that most financial institutions and insurance companies use CICS. Using CICS/TS on z/OS is still arguably the most efficient and cost-effective way to process millions of transactions daily.

CICS is called a mixed-language application server because it supports many different coding languages (from Java to COBOL). Moreover, not only does CICS support large volumes of transactions very efficiently, but it also acts as middleware, standing as a mediator between other programs, the UI, and the data.

<strong>Information Management System (IMS)</strong> is a database and transaction management system (just like CICS). It holds two components: the IMS Database Management System (IMS DB) and the IMS Transaction Management System (IMS TM). IMS DB, which is more widely used than IMS TM, is also known as a hierarchical database management software. This way the integrity of the data is ensured while the storage and retrieval process are optimized.
<h4 class="nocaps">TN3270 Emulators</h4>
Nowadays, you’ll mostly find 3270 terminals inside museums or in the possession of diehard IBM fans. But thanks to 3270 emulators, 3270 applications are still being used today. The most classic 3270 emulator is called the TN3270 emulator, or Telnet 3270 emulation software, which takes its name from the Telnet protocol it uses to communicate with the mainframe. There are TN3270 emulators for Mac, for Windows, and for Linux.
<h4 class="nocaps">TN3270 Protocol</h4>
The Telnet 3270 protocol (or TN3270) was based on the original Telnet protocol which was defined in RFC 854. The purpose of the Telnet Protocol is to provide a standard method of interfacing terminal devices and terminal-oriented processes to each other. TN3270 was built on this underlying protocol to allow the terminal emulator to communicate over TCP/IP networks.

At first, Telnet was an open, non-secure protocol. However, in 1995, specifications for securing it appeared (SSL, then TLS for instance). It is therefore possible and soon became a requirement to secure TN3270 communications, but many companies haven’t implemented it. Since it is sometimes difficult to configure encrypted data streams, implementing a VPN is often the chosen method. Many older versions of emulators do not support SSL, requiring the IT team to perform complicated maneuvers to support it.
<h4 class="nocaps">Wrap-Up</h4>
TN3270 emulators are also referred to as heavy-client emulators as they require the installation of a client software on each end-user device. However, this entails many admin obligations such as constantly and manually keeping it up to date on each end-user device.

While the 3270 terminal has completely disappeared from company offices, the 3270 family still survives to this day with its reliable applications and emulators. Moreover, the 3270 family is not frozen in time. Many innovations are being made for the 3270 family to this day.

For instance, thin-client TN3270 emulators like <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/">Virtel Web Access</a> can function solely with a modern web browser. They even have functionalities such as on-the-fly transformation of traditional “green screens” into modern pages. These emulators bring new quality of life functionalities and bridge the gap between legacy applications and the web.
[/av_textblock]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-2116' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:25:"0423-new-webinar-page-ssh";s:28144:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h1 class="secondary">SDS E-Business Server<sup>®</sup> | Webinar</h1>
[/av_textblock]

[av_textblock size='20' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="description">Enterprise-wide Encryption with SDS E-Business Server: New FIPS 140-2 Module Release and Other Highlights</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='3' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Watch Webinar' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='#e8e8e8' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Enterprise-wide Encryption with SDS E-Business Server:</h3>
<h4 class="nocaps" style="text-align: center;">New FIPS 140-2 Module Release and Other Highlights</h4>
<p style="text-align: center;">Educational webinar hosted by SHARE: July 17, 2019</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0' custom_margin_bottom='0' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/348663302' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">PGP Encryption - Layer #7 of the Secure FTP Onion</h4>
<p style="text-align: center;">(3 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830640' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Demonstration of PGP Encryption in action - Peeling the Secure FTP Onion</h4>
<p style="text-align: center;">(4 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/312778807' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">SDS E-Business Server: a Mainframe Security Compliance Solution</h4>
<p style="text-align: center;">(1 minute)</p>
[/av_textblock]

[av_video src='https://vimeo.com/321731016' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">SDS E-Business Server: Different User Interface Options</h4>
<p style="text-align: center;">(5 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/382526920' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' av_uid='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Webinar Details' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4>Make the most of the latest features</h4>
Watch this educational and complimentary webinar on <a href="/security-software/e-business-server/">E-Business Server</a> to learn about:
<ul>
 	<li>OpenPGP Standard - features and benefits.</li>
 	<li>SDS E-Business Server updates and key enhancements for z/OS, Windows, Linux, and AIX.</li>
 	<li>FIPS 140-2 validated SDS Cryptographic Module will be part of latest release for AIX, Linux, and Windows!  It's slated for a Q3 release.</li>
</ul>
[/av_textblock]

[av_button label='Request Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-449' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_video src='https://vimeo.com/291761546' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4>Our Presenters</h4>
<b class="black">Gary Bortner</b>, SDS, will discuss the key enhancements available in SDS E-Business Server for z/OS.

<b class="black">Jed Lampi</b>, SDS, will provide information on OpenPGP, the FIPS-validated module, and how this may help your organization.
<h3>About E-Business Server</h3>
<ul>
 	<li>Secure data at rest and in transit</li>
 	<li>Encrypt e-mail, file transfers, archives, desktops</li>
 	<li>Multi-platform versatility</li>
 	<li>APIs for z/OS, REXX, SYSREXX, C and Java</li>
 	<li>Automatic file compression and EBCDIC-ASCII conversions</li>
 	<li>Easy key generation and management</li>
 	<li>Unbreakable signature creation and authentication</li>
</ul>
The gold-standard in OpenPGP encryption software developed by cryptography pioneer Phil Zimmerman.

<hr />

This webinar is sponsored by Software Diversified Services (SDS).
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the E-Business Server Datasheet (opens in a new tab usually), <a href="https://sdsusastg.wpenginepowered.com/productdocs/EBS-datasheet.pdf">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the EBS Resources page, please <a href="/security-software/e-business-server/resources/">click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='hidecode' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' av_uid='' custom_class='hide']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="4"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/productdocs/EBS-datasheet.pdf',
			  '_blank'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' av_uid='' custom_class='hide']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="5"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/security-software/e-business-server/resources/',
			  '_self'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]
[/av_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<p style="text-align: center;">Want to see how well E-Business Server can perform on your environment? Your organization can try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-449' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:23:"0523-after-bb-text-left";s:5636:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Are You FTP’ing Files to z/OS Securely? Attend our Demo-Filled Webinar</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Watch this 30-minute webinar that explores securing inbound file traffic to z/OS.</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23084' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/file-security-gray.jpg' attachment='663' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][/av_layout_row]";s:24:"0523-after-bb-text-right";s:4883:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/file-security-gray-right.jpg' attachment='15792' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Are You FTP’ing Files to z/OS Securely? Attend our Demo-Filled Webinar</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Watch this 30-minute webinar that explores securing inbound file traffic to z/OS.</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23084' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:21:"0523-compliance-posts";s:15212:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h1 class="secondary">Mainframe Security Compliance - Main Components</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='20' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">April 13, 2023</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' id='' custom_class='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='small' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_full first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
Mainframes have been used for decades in industries that require large-scale processing and secure storage of sensitive data. While mainframes are known for their reliability and security, they are not immune to cyber threats.

In recent years, organizations in every industry have seen a dramatic uptick in security compliance requirements, with many of the new requirements targeting the mainframe. It is important for organizations to comply with regulatory requirements to ensure the security and confidentiality of data stored on mainframes.

Here are some of the key components of mainframe security compliance:
<ol>
 	<li>Regulatory Compliance</li>
Organizations must follow industry-specific regulations and standards that apply to their business. They must comply with a variety of regulatory frameworks such as GDPR, HIPAA, PCI DSS, and more. These regulations have been established to protect sensitive data from unauthorized access, theft, and misuse. Organizations must be familiar with which regulations they must comply with, then follow regulations on all their systems, especially on the mainframe where critical and sensitive data is often stored.
 	<li>Access Control</li>
Access control is a critical component of mainframe security. Organizations must ensure that access to the mainframe is limited to authorized personnel only and limit access within the mainframe. User access controls must be enforced to ensure that users can only access the data they need to perform their job functions. Access to the mainframe must be controlled through secure authentication and authorization mechanisms such as passwords, tokens, and biometric authentication.
 	<li>Physical Security</li>
Physical security is another key component of mainframe security compliance. Organizations must ensure that mainframes are housed in secure data centers that are equipped with environmental controls, fire suppression systems, and other safety measures. Access to the data center must be controlled and monitored. Visitors must be subject to strict identification and clearance procedures. Physical security must also extend to the storage media used in mainframes. Sensitive data must be stored on encrypted tapes or other storage media that cannot be accessed by unauthorized individuals.
 	<li>Network Security</li>
Network security is an important component of mainframe compliance. Mainframes should be isolated from external networks such as the internet to reduce the risk of cyber attacks. Organizations must implement firewalls and intrusion detection systems to monitor and control incoming and outgoing network traffic. Access to the mainframe must be controlled through secure virtual private networks (VPNs) and other security measures.
 	<li>Encryption</li>
Encryption is another important component of mainframe security compliance. Sensitive data must be encrypted to ensure that it cannot be accessed by unauthorized individuals. Organizations must ensure that encryption keys are stored securely and that encryption algorithms are kept up-to-date to maintain the security of encrypted data. With quantum computing capabilities just around the corner, it’s important to use “quantum-safe” algorithms.
 	<li>Auditing and Monitoring</li>
Auditing and monitoring are essential components of all security compliance mandates. Organizations must implement audit trails and logs to track user activity on the mainframe. This information can be used to detect unauthorized access attempts and other security incidents. Organizations must regularly review audit trails to ensure that users are complying with security policies and procedures.
 	<li>Disaster Recovery and Business Continuity</li>
Disaster recovery and business continuity planning are important aspects of running any business and also are featured prominently in compliance regulations. Organizations must have plans in place to ensure that mainframe operations can continue in the event of a disaster or other disruption. These plans should include backup and recovery procedures, redundant systems, and other measures to ensure that data and applications are available when needed.
 	<li>Training and Awareness</li>
Training and awareness are critical components of mainframe compliance. Employees must be trained on security policies and procedures. Mainframe administrators must be aware of their responsibilities for maintaining the security and confidentiality of sensitive data. Organizations must also conduct regular security awareness training to ensure that employees are up-to-date on the latest security threats and best practices.</ol>
Following relevant security compliance regulations will help maintain the security and integrity of sensitive data stored on mainframe systems. Organizations must comply with regulatory frameworks, implement access controls, ensure physical and network security, encrypt sensitive data, implement auditing and monitoring, have disaster recovery and business continuity plans in place, and provide training and awareness for employees. Mainframe compliance is an ongoing process that requires continuous monitoring and improvement.

Organizations that implement security-focused tools on the mainframe will be in a better position to comply with their security compliance requirements. They are also much less likely to have a major security breach.
[/av_textblock]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-694' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:33:"0523-iron-individual-webinar-page";s:28760:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='#acacac' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' custom_class='' av_uid='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h1 class="secondary">IronSphere for z/OS | Webinar</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">Automatic STIG Compliance Monitoring for z/OS and iSeries with One Tool</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' custom_class='' av_uid=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-slide-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='4' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Watch Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Automatic STIG Compliance Monitoring for z/OS and iSeries with One Tool</h3>
<p style="text-align: center;">SDS IronSphere for z/OS webinar - March 15, 2023</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_video src='https://vimeo.com/808415103' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Handouts' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_masonry_gallery ids='22949,7423,15539' caption_elements='title excerpt' caption_styling='' caption_display='always' img_copyright='' size='flex' orientation='' image_size='no scaling' gap='large' columns='flexible' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='' custom_bg='' img_copyright_font='' av-desktop-font-img_copyright_font='' av-medium-font-img_copyright_font='' av-small-font-img_copyright_font='' av-mini-font-img_copyright_font='' img_copyright_color='' img_copyright_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='_blank' lightbox_text='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section][av_tab_sub_section tab_title='Webinar Details' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 class="nocaps">Automatic STIG Compliance Monitoring for z/OS and iSeries</h4>
This 30-minute webinar will cover:
<ul>
 	<li>Explore the changing threat landscape and the need for IronSphere on z/OS and iSeries.</li>
 	<li>Go over what IronSphere does and how it can help your organization.</li>
 	<li>Show IronSphere in action with a demo.</li>
</ul>
<strong>We hope you can join us for this webinar on Wednesday, March 15 at 1:00PM CT.</strong>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='_blank' size='large' position='left' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='90%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Featured Presenter:</h3>
<ul>
 	<li><b class="black">Itschak Mugzach</b>, founder and managing director of SecuriTeam software, creator of IronSphere for z/OS and iSeries.</li>
</ul>
Itschak will explore the changing threat landscape and how IronSphere will help your organization's z/OS and iSeries security. There will also be a brief product demo.
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h5 class="nocaps" style="text-align: center;">IronSphere for z/OS and iSeries</h5>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_font='' custom_bg='#bf1a2d' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='nocaps' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Stronger, Standards-based Mainframe Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Automate Tedious STIG Compliance Work' icon='ue864' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title=' More Manageable Compliance Mandates' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Find & Display Security Vulnerabilities' link='' linktarget='' linkelement='' icon='ue8de' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Simple Risk Remediation Steps Provided' link='' linktarget='' linkelement='' icon='ue84b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Help for Auditors; Painless Future Audits' link='' linktarget='' linkelement='' icon='ue803' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Abstract</h3>
Learn all about IronSphere for z/OS and iSeries in this presentation, featuring Itschak Mugzach, founder of IronSphere.

Staying up to date on DISA STIGs and NIST ISCM requirements and then checking to verify your mainframe is passing these security standards is continuous and a lot of ongoing work and hassle.  

<strong>Why not automate these cumbersome tasks instead?</strong>

This STIG-reporting tool will find security issues now. Don’t wait for audit time; follow risk-based security and compliance protocols for the mainframe.  Baselines are created in short cycles, diagnostic routines are triggered, and up-to-date reports along with calculated risk scores for your monitored systems are displayed.
<h4 class="nocaps">During this presentation, we will:</h4>
<ul>
 	<li>Explore the changing threat landscape and the need for IronSphere on z/OS and iSeries.</li>
 	<li>Go over what IronSphere does and how it can help your organization.</li>
 	<li>Show IronSphere in action with a demo.</li>
</ul>
<strong>We hope you can join us for this webinar on Wednesday, March 15 at 1:00PM CT.</strong>
<h4 class="nocaps">More about IronSphere:</h4>
IronSphere continuously monitors z/OS and iSeries systems, comparing your system to DISA STIG and NIST ISCM standards.  When vulnerabilities are identified, complete remediation steps are delivered.

If your organization is following security standards on the mainframe, compare the simplicity that IronSphere provides to the process you're undertaking today.

IronSphere for z/OS and iSeries - product details:
<ul>
 	<li>Automated, real-time STIG compliance monitoring and remediation.</li>
 	<li>Continuous cybersecurity monitoring and auditing.</li>
 	<li>Customizable:
<ul>
 	<li>remove checks with documentation,</li>
 	<li>create new checks,</li>
 	<li>request additional checks be created by IronSphere team.</li>
</ul>
</li>
 	<li>Results are provided in a GUI, perfect for security folks and other non-mainframers.</li>
</ul>

<hr />

This webinar is sponsored by Software Diversified Services (SDS).
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_portfolio categories='54' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' period_filter_unit_1='1' period_filter_unit_2='year' sort='yes' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section]
[/av_tab_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:26:"0523-sftp-web-text-left-bb";s:5625:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Are You FTP’ing Files to z/OS Securely? Attend our Demo-Filled Webinar</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us for this 30-minute webinar on May 10, 2023 at 1:00PM CT!</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23032' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/file-security-gray.jpg' attachment='663' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half]
[/av_layout_row]";s:31:"0523-sftp-webinar-text-right-bb";s:4872:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/file-security-gray-right.jpg' attachment='15792' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Are You FTP’ing Files to z/OS Securely? Attend our Demo-Filled Webinar</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us for this 30-minute webinar on May 10, 2023 at 1:00PM CT!</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23032' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:24:"0523-webinar-details-tab";s:12584:"[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='1' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Webinar Details' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 class="nocaps">Securing inbound file transfers to z/OS via SFTP</h4>
We will be demonstrating the following concepts using Tectia SSH:
<ul>
 	<li>Storing files directly into z/OS datasets (no staging of files in a zFS file system)</li>
 	<li>Configuring and using File transfer profiles to simplify upload transfers to z/OS</li>
 	<li>Transferring z/OS GDG’s</li>
 	<li>FTP subcommands vs SFTP commands</li>
</ul>
<b>Join us for this 30-minute webinar on Wednesday, May 10 at 1:00PM CT.</b>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://my.demio.com/ref/kCP4JuSOdGMftg0y?source=sdsusa' link_target='_blank' size='large' position='left' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='#acacac' radius='0px' radius_sync='true' min_col_height='' padding='20px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_video src='https://vimeo.com/340636665' attachment=',' attachment_size=',' mobile_image='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_one_half][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4>Featured Presenter</h4>
<b class="black">Colin van der Ross</b>, Sr. Systems Engineer, has been with Software Diversified Service for 14 years. His experience ranges from TCPIP, Network Management, Security and Network performance solutions. Prior to working for SDS, Colin was a Systems Programmer at a large bank for more than 20 years.
<h4>Abstract</h4>
Tectia® SSH can act as both a Server (inbound to z/OS) and Client (outbound from z/OS). Recently, due to compliance and security requirements, SDS has seen an uptick on customers wanting to transfer files securely to the mainframe.

However, the migration of scripts on distributed servers to SFTP command syntax can be a daunting task for customers. In this webinar, we plan to demonstrate how customers can use Tectia SSH to send files from distributed platforms to z/OS and how easy the migration process is when using File Transfer profiles.

We will cover and demonstrate the following topics:
<ul>
 	<li>Storing files directly into z/OS datasets (no staging of files in a zFS file system)</li>
 	<li>Configuring and using File transfer profiles to simplify upload transfers to z/OS</li>
 	<li>Transferring z/OS GDG’s</li>
 	<li>FTP subcommands vs SFTP commands</li>
</ul>

<hr />

This webinar is sponsored by Software Diversified Services (SDS).
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VFTP-SSH Datasheet (opens in a new tab usually), <a href="https://sdsusastg.wpenginepowered.com/productdocs/VFTP-SSH-datasheet.pdf">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VFTP-SSH Resources page, please <a href="/security-software/vftp-ssh/resources/">click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]";s:23:"524-new-bottom-sections";s:4506:"[av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='5px' radius_sync='true' min_col_height='' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Learn More</h3>
[/av_textblock]

[av_masonry_gallery ids='23882,23885,23890,23884' caption_elements='title' caption_styling='' caption_display='always' img_copyright='' size='flex' orientation='' image_size='no scaling' gap='large' columns='2' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='custom' custom_bg='#cacaca' img_copyright_font='' av-desktop-font-img_copyright_font='' av-medium-font-img_copyright_font='' av-small-font-img_copyright_font='' av-mini-font-img_copyright_font='' img_copyright_color='' img_copyright_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='' lightbox_text='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='masonwborders' template_class='' av_uid='' sc_version='1.0']
[/av_three_fifth]";s:19:"524-vftpssh-new-top";s:5702:"[av_one_half min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='10px,25px' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='#acacac' radius='0px' radius_sync='true' min_col_height='' padding='20px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#cacaca' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">VFTP-SSH - Key Benefits of Securing z/OS FTP with this FTP-to-SFTP Conversion Solution:</h3>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='14' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='' custom_bg='#bf1a2d' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='nocaps' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='rgb(241, 241, 241)']
[av_iconlist_item title='Automatic FTP-to-SFTP Conversion' link='' linktarget='' linkelement='' icon='ue864' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' title_attr='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Pass FTP-related Compliance Requirements' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' title_attr='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Multi-layered Data Transfer Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' title_attr='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='No JCL Changes' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' title_attr='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Visibility of all Transfers to/from Mainframe' icon='ue804' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' title_attr='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Integrate z/OS FTP Server with your SAF for Added Security' icon='ue894' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' title_attr='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[av_video src='https://vimeo.com/340636665' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half]";s:33:"0621-ebs-newsletter-post-template";s:11813:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h1 class="secondary">Recent Enhancements of SDS E-Business Server for z/OS</h1>
[/av_textblock]

[av_textblock size='20' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="description">SDS E-Business Server Encryption News: March 2019 Edition</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' id='' custom_class='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='small' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='' av_element_hidden_in_editor='0']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock size='15' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: right;"><a href="/newsdocs/EBS-news4-recent-enhancements-ebs-zos.pdf" target="_blank" rel="noopener"><em>Encryption News for March 2019 - PDF</em></a></p>

<a href="/security-software/e-business-server/">SDS E-Business Server<sup>®</sup></a> is designed for companies that require the highest levels of protection for data stored internally, transmitted within their organization, and distributed beyond their firewalls. E-Business Server offers strong encryption that integrates with a wide range of applications and platforms, including the mainframe.

Did you know that for over 5 years, SDS has been continually adding new features to E-Business Server, many specifically for z/OS?
<h4 class="nocaps">SDS E-Business Server 7.8 introduced new key management capabilities:</h4>
An ISPF interface that allows users to invoke E-Business Server commands from a TSO panel. Users can perform key management functions like generating, adding, removing, exporting, signing, and listing details for keys.

Part of this enhancement was the creation of the <a href="https://sdsusastg.wpenginepowered.com/security-software/e-business-server/ebsmap-utility/">EBSmap Utility for z/OS</a>. One of the main functions available through EBSmap is to look at a partner’s key before adding to your keyring. You can determine the keyid, userid, key size, key type (DSA or RSA), symmetric ciphers, and compression algorithms.
<h4 class="nocaps">SDS E-Business Server 7.9.3 was released Feb 28, 2019. New features include:</h4>
<ul>
 	<li>More information provided on a dynamic allocation error.</li>
 	<li>New switch to allow multiple input files to be decrypted to a single output file.</li>
 	<li>New readonly option for the keyring to reduce keyring corruption when multiple jobs are run at the same time.</li>
</ul>
<h5 class="nocaps">Find out how SDS E-Business Server can help your organization’s mainframe security and compliance needs:</h5>
View the <a href="/productdocs/EBS-datasheet.pdf" target="_blank" rel="noopener">SDS E-Business Server Datasheet</a>. Please email <a href="mailto:info@sdsusa.com">info@sdsusa.com</a> to request additional information or a 30-day free trial.

<hr />

<a href="/"><img class="aligncenter wp-image-11606" src="/wp-content/uploads/SDS-logo-quality-software.png" alt="SDS quality software since 1982" width="50%" /></a>

Software Diversified Services delivers comprehensive, affordable mainframe and distributed software with a focus on cybersecurity and compliance. Hundreds of organizations worldwide, including many Fortune 500 companies, rely on SDS solutions. Our expert development and award-winning technical support teams are based in Minnesota, USA. To learn more, please visit <a href="/">sdsusastg.wpenginepowered.com</a>.
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]

[av_one_full first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']
[av_portfolio categories='68' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' columns='4' one_column_template='special' items='16' contents='excerpt' preview_mode='auto' image_size='portfolio' linking='' sort='no' paginate='yes' query_orderby='name' query_order='DESC' av-medium-columns='' av-small-columns='' av-mini-columns='' id='' custom_class='' av_uid='']
[/av_one_full]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-449' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:28:"0623-vsr-bb-after-text-right";s:5735:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/coding-gray-right.jpg' attachment='23142' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Modernize your 3270 Application Screens with Virtel's Visual Screen Redesigner</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">See how easy it is to completely transform legacy application UIs. The vast majority of this 30-minute webinar is demonstrating how VSR works!</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23209' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:27:"0623-vsr-bb-font-right-gray";s:5704:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/coding-gray-right.jpg' attachment='23142' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Modernize your 3270 Application Screens with Virtel Visual Screen Redesigner</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us for this 30-minute webinar on June 15, 2023 @ 1:00PM CT.</p>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://my.demio.com/ref/UZh1KTYg42LuURBm' link_target='_blank' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]";s:31:"0623-vsr-bb-red-font-left-after";s:6485:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Modernize your 3270 Application Screens with Virtel Visual Screen Redesigner</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">See how easy it is to completely transform legacy application UIs. The vast majority of this 30-minute webinar is demonstrating how VSR works!</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23209' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/coding-red.jpg' attachment='675' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][/av_layout_row]";s:25:"0623-vsr-bb-text-left-red";s:6456:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Modernize your 3270 Application Screens with Virtel Visual Screen Redesigner</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us for this 30-minute webinar on June 15, 2023 @ 1:00PM CT.</p>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://my.demio.com/ref/UZh1KTYg42LuURBm' link_target='_blank' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/coding-red.jpg' attachment='675' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half]
[/av_layout_row]";s:33:"0623-vsr-gray-bb-font-right-after";s:5733:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/coding-gray-right.jpg' attachment='23142' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Modernize your 3270 Application Screens with Virtel Visual Screen Redesigner</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">See how easy it is to completely transform legacy application UIs. The vast majority of this 30-minute webinar is demonstrating how VSR works!</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23209' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:13:"0623-vwm-page";s:28611:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h1 class="secondary">Virtel<sup>®</sup> Web Modernization | VWM</h1>
[/av_textblock]

[av_textblock size='20' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="description">Serve 3270 legacy host application screens as modern and user-friendly web pages</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='']
[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Modern GUI for 3270 Applications</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
VWM makes it simple and fast to serve legacy host applications (CICS, IMS, Natural, etc.) as modern GUI webpages. This creates a user-friendly web portal experience with:
<ul>
 	<li>Updated workflow: screen consolidation, tab navigation, and collapsible sections</li>
 	<li>Widget-assisted data entry: checkboxes, dropdown lists, and graphical calendars</li>
 	<li>New Ajax application features: suggest, auto-complete, PDF generation, and emailing</li>
</ul>
With VWM in place, users will think they are accessing a genuine web application, not a legacy mainframe application.

Because they rely on standard (HTML/JavaScript) web technology, VWM’s GUI pages will work instantly with any web-enabled device.
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-2546' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<div style="padding: 56.25% 0 0 0; position: relative;"><iframe style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;" src="https://vimeo.com/album/4422963/embed" frameborder="0" allowfullscreen="allowfullscreen"></iframe></div>

<hr />

With the Virtel Studio and Virtel Screen Redesigner IDEs, developing a VWM web portal is ten times faster and less expensive than rehosting, replacing, or redeveloping the host application. It doesn’t require changing the legacy code, and can be done progressively, a few 3270 screens at a time.

<strong>VWM extends the relevance of - and investment in - legacy host applications by replacing their dated screen UI with a modern and user-friendly GUI.</strong>
[/av_textblock]

[/av_one_half]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='#e8e8e8' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' custom_class='' av_uid='']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' av_uid='']
<h4 style="text-align: center;">Cost Savings</h4>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<p style="text-align: center;">Replacing the screen UI with a Graphical UI may enable transferring the responsibility and cost of driving the 3270 transactions from internal staff to business partners and customers through self-service access to products and services.</p>
<p style="text-align: center;">Virtel’s centralized installation, administration, and support result in significant savings across the board.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' av_uid='']
<h4 style="text-align: center;">Growth</h4>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<p style="text-align: center;">Replacing screen UIs with graphical UIs extends the relevance of - and investment in - legacy host applications.</p>
<p style="text-align: center;">It can help grow revenues by extending some products and services in self-service mode directly to business partners, customers, and consumers.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' av_uid='']
<h4 style="text-align: center;">Productivity</h4>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<p style="text-align: center;">Modern user-friendly web portals eliminate data entry errors through assisted data entry widgets.</p>
<p style="text-align: center;">They eliminate the toggle between screen and web user interfaces. They reduce the training requirements for new and temporary staff. They make it easier to attract new staff that would otherwise be turned off by outdated green screen interfaces.</p>
[/av_textblock]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av_uid='']
<h3>Features</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<ul>
 	<li>Serves 3270 transactions as modern and user-friendly GUI pages</li>
 	<li>Creates a genuine web portal experience</li>
 	<li>Low impact and low risk: no application change required</li>
 	<li>Easy deployment: simply point the client web browsers to an installation-defined URL</li>
 	<li>Works instantly with any web-enabled client regardless of OS, device, or browser</li>
 	<li>Centralized (host-based) installation, management, and support</li>
 	<li>Host retains full control of access to its own assets</li>
 	<li>No new licensing or installation to support new client technology</li>
 	<li>Along with <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/">Virtel Web Access</a> and <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-integration/">Virtel Web Integration</a>, VWM is a key part of a cost-effective and speedy <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/2019-webisode-series/">digital transformation plan</a></li>
</ul>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='30px' padding_sync='true' border='' border_color='' radius='5px' radius_sync='true' background_color='#e8e8e8' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' custom_class='' av_uid='']

[av_font_icon icon='ue84b' font='entypo-fontello' style='' caption='' link='' linktarget='' size='40px' position='center' color='#acacac' av_uid=''][/av_font_icon]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#bf1a2d' av_uid='']
<h4 style="text-align: center;">Datasheet</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_button label='Download' link='manually,/productdocs/VWM-datasheet.pdf' link_target='_blank' size='large' position='center' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue887' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='']

[av_hr class='invisible' height='60' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_font_icon icon='ue8bb' font='entypo-fontello' style='' caption='' link='' linktarget='' size='40px' position='center' color='#acacac' av_uid=''][/av_font_icon]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#bf1a2d' av_uid='']
<h4 style="text-align: center;">Resources</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_button label='View' link='page,5055' link_target='' size='large' position='center' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='']

[/av_one_third]
[/av_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/coding-gray-right.jpg' attachment='23142' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Modernize your 3270 Application Screens with Virtel Visual Screen Redesigner</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us for this 30-minute webinar on June 15, 2023 @ 1:00PM CT.</p>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://my.demio.com/ref/UZh1KTYg42LuURBm' link_target='_blank' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;">Digital Transformation:</h2>
<h2 class="nocaps" style="text-align: center;">Continue using Mainframe Applications with a Practical Approach</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Thanks to all who joined us for this webinar discussing the <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/">Virtel Web Suite</a> as an excellent digital transformation candidate.</p>
[/av_textblock]

[av_button label='Webinar Details' link='page,9285' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/tablet-red-banner.jpg' attachment='15858' attachment_size='full' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-2546' av_uid='' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:20:"0624-best-new-bottom";s:4505:"[av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='5px' radius_sync='true' min_col_height='' padding='0px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Learn More</h3>
[/av_textblock]

[av_masonry_gallery ids='23967,23970,23969,23968' caption_elements='title' caption_styling='' caption_display='always' img_copyright='' size='flex' orientation='' image_size='no scaling' gap='large' columns='2' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='custom' custom_bg='#e8e8e8' img_copyright_font='' av-desktop-font-img_copyright_font='' av-medium-font-img_copyright_font='' av-small-font-img_copyright_font='' av-mini-font-img_copyright_font='' img_copyright_color='' img_copyright_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='' lightbox_text='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='masonwborders' template_class='' av_uid='' sc_version='1.0']
[/av_three_fifth]";s:23:"0624-iron-contactbutton";s:4712:"[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='0px,10px' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='#bf1a2d' radius='0px' radius_sync='true' min_col_height='' padding='15px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_button label='Contact SDS for Additional Information' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='0' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[/av_one_full]";s:14:"0624-iron-tabs";s:64132:"[av_tab_section transition='av-tab-slide-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='1' bg_color='#7f7f7f' color='#ffffff' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Product Details' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,30px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Real-Time <span class="lower">z</span>/OS Risk Awareness</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
This continuous monitoring solution can further strengthen even the most secure mainframe. <em>SDS IronSphere for z/OS also provides assistance for, while complying with, standards that U.S. Federal Government agencies are required to follow</em>. <b>Automatic z/OS STIG compliance monitoring is a major highlight</b>, but IronSphere offers many more security compliance features for the mainframe.
<h4 class="nocaps">IronSphere for z/OS follows Frameworks and Guidelines</h4>
This tool was created by mainframe penetration testers and compliance-minded, security experts. Due to their experience in the field, IronSphere for z/OS follows the guidelines that play integral roles in the framework of security compliance mandates and are required to be followed within certain sectors.
<h4 class="nocaps">IronSphere provides Mainframe Compliance Assistance by:</h4>
<ul>
 	<li><b class="black">Adhering to <a href="https://www.nist.gov/publications/information-security-continuous-monitoring-iscm-federal-information-systems-and" target="win2">NIST ISCM</a></b> (<em>Information Security Continuous Monitoring</em>) Guidelines</li>
 	<li><b class="black">Following <a href="https://www.nist.gov/cyberframework" target="win2">NIST CSF</a></b> (Cybersecurity Framework)</li>
 	<li><b class="black">Following <a href="https://csrc.nist.gov/projects/risk-management/risk-management-framework-(rmf)-overview" target="win2">RMF</a></b> (<em>Risk Management Framework</em>)</li>
 	<li><b class="black">Automatically running security diagnostic scans based on <a href="https://www.disa.mil/" target="win2">DISA</a></b> (<em>Defense Information Systems Agency</em>) <b><a href="https://iase.disa.mil/stigs/Pages/index.aspx" target="win2">STIGs</a></b> (<em>Security Technical Implementation Guides</em>) - Compliance to DISA STIGs is a DoD requirement</li>
</ul>
This tool also assists in complying with many additional standards (GDPR, FISMA, etc.) by following above frameworks.
<h4 class="nocaps">How will IronSphere help your Organization?</h4>
This solution <b class="black">automatically and continuously identifies system risks, then delivers easy-to-follow remediation steps</b> as part of the assessment results. In addition, results are kept within the tool, proving to compliance auditors that you've been continuously monitoring your z/OS system and adhering to ISCM and RMF protocols.

This mainframe solution offers a new level of system visibility by <b class="black">displaying z/OS scan results and system vulnerabilities in a GUI with a "40,000 foot view"</b> for specialized experts within the Security and GRC Teams, Upper-Level Managers, and the z/OS Mainframe Team. The display also contains more details to satisfy and guide z/OS team members charged with implementing the fixes detailed in the guides.

<strong>Automate z/OS STIG compliance and add security with IronSphere.</strong>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][av_one_half min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='10px,25px' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='#acacac' radius='0px' radius_sync='true' min_col_height='' padding='20px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#e8e8e8' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">IronSphere for z/OS - Key Benefits</h3>
<h4 class="nocaps" style="text-align: center;">Simplify z/OS Security Compliance by Automating STIGs</h4>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' animation='' alb_description='' id='' custom_class='nocaps' av_uid='' admin_preview_bg='']
[av_iconlist_item title='Stronger, Standards-based Mainframe Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Automate Tedious <span class="lower">z</span>/OS STIG Process' icon='ue864' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid=''][/av_iconlist_item]
[av_iconlist_item title=' More Manageable Compliance Mandates' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Find & Display Security Vulnerabilities' link='' linktarget='' linkelement='' icon='ue8de' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Simple Risk Remediation Steps Provided' link='' linktarget='' linkelement='' icon='ue84b' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Help for Auditors; Painless Future Audits' link='' linktarget='' linkelement='' icon='ue803' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[/av_iconlist]

[av_video src='https://vimeo.com/showcase/5300985' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='10px,0px' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='#bf1a2d' radius='0px' radius_sync='true' min_col_height='' padding='15px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">IronSphere - Recently Added Features</h3>
[/av_textblock]

[/av_one_full][av_one_third first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='10px,2%,10px,4%' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='#ffffff' custom_bg='#525252' custom_border='#525252' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='10+ Supplemental Product Packs Available' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_third][av_one_third min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='10px,2%,10px,4%' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='#ffffff' custom_content='' color='custom' custom_font='#ffffff' custom_bg='#525252' custom_border='#525252' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='iSeries Support Available' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_third][av_one_third min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='10px,2%,10px,4%' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='#ffffff' custom_content='' color='custom' custom_font='#ffffff' custom_bg='#525252' custom_border='#525252' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Latest STIGs from DISA Available' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_third][av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='0px,10px' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='#bf1a2d' radius='0px' radius_sync='true' min_col_height='' padding='15px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_button label='Contact SDS for Additional Information' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='0' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_full][av_two_third first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='30px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='1' border_style='solid' border_color='#bf1a2d' radius='0px' radius_sync='true' min_col_height='' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Additional Checks and Flexibility</h4>
Many z/OS components lacking DISA STIGs already have their own checks created on the IronSphere system and can be made available to users. <b class="black">If you need another set of checks, simply request it and it'll be configured ASAP</b>.

Also, some organizations may require even more flexibility. <b class="black">New checks can be created by your team, tailored to fit your needs, and implemented within the product.</b> With these new checks and the power of IronSphere, you have the ability to setup acceptable limits and standards for your mainframe components not covered by a DISA STIG.

Just like any typical component with a DISA STIG on IronSphere, security vulnerabilities and remediation steps are provided after running these checks is complete.
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/DBTA-TSP-2021-logo.png' attachment='20812' attachment_size='full' copyright='' caption='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='' appearance='' link='manually,https://www.dbta.com/Editorial/Trends-and-Applications/Trend-Setting-Products-in-Data-and-Information-Management-for-2021-144175.aspx' target='_blank' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_one_third][av_one_third first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='0px,20px' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='30px,40px,30px,40px' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#e8e8e8' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' av_uid='']
<h4 style="text-align: center;">Compliance</h4>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">This z/OS security tool will reduce workload required to comply with government regulatory standards as compliance was major focus during development. IronSphere can help become compliant with NIST ISCM, FISMA, GDPR, and others; it uses DISA STIGs and can facilitate Risk Management Framework implementation on the mainframe.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='30px,40px,30px,40px' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' custom_class='' av_uid='']
<h4 style="text-align: center;">GUI Display</h4>
[/av_textblock]

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<p style="text-align: center;">Mainframe expertise is not required to view and understand the system's risks and the course of action that must be followed to resolve them!  The GUI provides an opportunity for those outside of the mainframe world to have visibility into this critical system and its vulnerabilities.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='30px,40px,30px,40px' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' custom_class='' av_uid='']
<h4 style="text-align: center;">Security</h4>
[/av_textblock]

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<p style="text-align: center;">IronSphere has the ability to provide additional mainframe security on top of your already hardened system! It does this by identifying vulnerabilities and system issues through continuous monitoring. Following standards and all best practices will result in achieving an unthinkable level of z/OS security and smooth audits.</p>
[/av_textblock]

[/av_one_third][av_two_fifth first min_height='' vertical_alignment='av-align-middle' space='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='30px,0px' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='0px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock size='' font_color='' color='' av_uid='']
<h3>Features</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li>An ISCM, RMF-based tool that continuously monitors the mainframe on an optimal schedule</li>
 	<li>Real-time z/OS monitoring helps protect data, achieve top-level security, comply with standards</li>
 	<li>Helps pass security compliance protocols for z/OS: NIST ISCM, DISA, FISMA, GDPR, & more</li>
 	<li>GRC for z/OS solution; ideal for many industries: government, financial, insurance</li>
 	<li>Doesn't require z/OS expertise to interpret results in GUI; additional fix information for z/OS Team</li>
 	<li>Provides a single point of reporting for mainframe system health and risks to the system</li>
 	<li>Saves resources via automatic delivery of DISA STIGs for required system software updates</li>
 	<li>Lowers overhead and lessens reliance on scarce, experienced mainframe experts; better use of experts</li>
 	<li>Lean agent gathers data on mainframe efficiently, leaves no trace behind</li>
 	<li>Flexible solution: define user roles, create your own system checks/STIGs, and can configure other settings</li>
 	<li>Runs on many mainframe operating systems: z/OS, Linux on IBM Z, z/VSE, z/VM, z/TPF, AS/400</li>
 	<li>Enhanced security, advanced breach avoidance, compliance for large organizations</li>
 	<li>Helps smaller z/OS shops with best practices, heightened security, lower costs through automatic process</li>
</ul>
[/av_textblock]

[/av_two_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='5px' radius_sync='true' min_col_height='' padding='0px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Learn More</h3>
[/av_textblock]

[av_masonry_gallery ids='23928,23931,23930,23929' caption_elements='title' caption_styling='' caption_display='always' img_copyright='' size='flex' orientation='' image_size='no scaling' gap='large' columns='2' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='custom' custom_bg='#e8e8e8' img_copyright_font='' av-desktop-font-img_copyright_font='' av-medium-font-img_copyright_font='' av-small-font-img_copyright_font='' av-mini-font-img_copyright_font='' img_copyright_color='' img_copyright_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='' lightbox_text='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='masonwborders' template_class='' av_uid='' sc_version='1.0']

[/av_three_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='1 Minute Overview' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,20px' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">IronSphere: z/OS STIG Compliance Automation and Mainframe Security</h3>
<h4 class="nocaps" style="text-align: center;"><span style="color: #525252;">1 Minute Overview</span></h4>
[/av_textblock]

[/av_one_full][av_one_third first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><span style="color: #525252;">Key Benefits:</span></h3>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' custom_content_size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='nocaps' admin_preview_bg='']
[av_iconlist_item title='Even Stronger Mainframe Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Automate z/OS STIG Compliance Work' link='' linktarget='' linkelement='' icon='ue864' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title=' More Manageable Compliance Mandates' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Find & Display Security Vulnerabilities' link='' linktarget='' linkelement='' icon='ue8de' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Help for Auditors; Painless Future Audits' link='' linktarget='' linkelement='' icon='ue803' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><span style="color: #525252;">IronSphere Automatically and Continuously:</span></h3>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='' custom_content_size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='nocaps' admin_preview_bg='']
[av_iconlist_item title='Runs Security Diagnostic Checks on Mainframe' link='' linktarget='' linkelement='' icon='ue856' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Complies with ISCM, RMF, DISA STIGs for z/OS' link='' linktarget='' linkelement='' icon='ue803' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Provides Simple Steps to Remediate Issues' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Updates Your Security Risks & Fix Status on GUI' link='' linktarget='' linkelement='' icon='ue86c' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Updates Audit Log with Scan Results' link='' linktarget='' linkelement='' icon='ue851' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Differentiators vs. Competing Solutions:</h3>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' animation='' custom_title_size='' custom_content_size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='nocaps' admin_preview_bg='']
[av_iconlist_item title='Run Scans on Regular Schedule' link='' linktarget='' linkelement='' icon='ue891' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='No Work on Your End to Run Scans' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Receive Real-Time Remediation Guidance' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='GUI Display Provides Added Visibility' link='' linktarget='' linkelement='' icon='ue826' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_third][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='#e8e8e8' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[/av_tab_sub_section][av_tab_sub_section tab_title='Webinar' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the IronSphere Webinar page, please <a href="/security-software/automatic-mainframe-stig-monitoring/webinar/">click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='ironsphere']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='10px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the IronSphere Datasheet (opens in a new tab usually), <a href="/productdocs/automate-zOS-STIGs-datasheet.pdf" target="_blank" rel="noopener">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_portfolio categories='54' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' period_filter_unit_1='1' period_filter_unit_2='year' sort='yes' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section]
[/av_tab_section]";s:23:"0624-new-bottom-section";s:4507:"[av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='5px' radius_sync='true' min_col_height='' padding='0px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Learn More</h3>
[/av_textblock]

[av_masonry_gallery ids='23967,23970,23969,23968' caption_elements='title' caption_styling='' caption_display='always' img_copyright='' size='flex' orientation='' image_size='no scaling' gap='large' columns='2' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='custom' custom_bg='#cacaca' img_copyright_font='' av-desktop-font-img_copyright_font='' av-medium-font-img_copyright_font='' av-small-font-img_copyright_font='' av-mini-font-img_copyright_font='' img_copyright_color='' img_copyright_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='' lightbox_text='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='masonwborders' template_class='' av_uid='' sc_version='1.0']

[/av_three_fifth]";s:14:"0624-top-image";s:5482:"[av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='20px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#e8e8e8' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/pgp-encryption-decryption-process-1.png' attachment='23987' attachment_size='full' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]
[/av_one_half]";s:23:"0824-Learn-More-updated";s:4514:"[av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='5px' radius_sync='true' min_col_height='' padding='0px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Learn More</h3>
[/av_textblock]

[av_masonry_gallery ids='24173,24183' ids_dynamic='' caption_elements='title' caption_styling='' caption_display='always' img_copyright='' size='flex' orientation='' image_size='no scaling' gap='large' columns='2' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='custom' custom_bg='#cacaca' img_copyright_font='' av-desktop-font-img_copyright_font='' av-medium-font-img_copyright_font='' av-small-font-img_copyright_font='' av-mini-font-img_copyright_font='' img_copyright_color='' img_copyright_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='_blank' lightbox_text='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='masonwborders' template_class='' av_uid='' sc_version='1.0']
[/av_three_fifth]";s:23:"0923-onion-webinar-tabs";s:29116:"[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='2' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Watch Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Peeling the Onion Tutorial</h3>
<h4 class="nocaps" style="text-align: center;">Exploring Viable Means to Perform Secure Mainframe File Transfers</h4>
<p style="text-align: center;">Educational webinar: January 16, 2019</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0' custom_margin_bottom='0' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/sdsusa/secure-ftp' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Webinar Details' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4>Options to Secure Data and File Transfers on <span class="lower">z</span>/OS</h4>
This educational SHARE<sup>®</sup> webinar will explore data security on the mainframe, focusing on ways to <a href="/security-software/vftp-ssh/">secure z/OS file transfers</a>.

<strong>The updated <em>Peeling the Onion</em> Tutorial will be well worth your time.  Why?
</strong>
<ol>
 	<li>Your most important and sensitive data is likely housed on your mainframe.</li>
 	<li>Securing that data during transfer isn’t guaranteed and is a crucial compliance mandate with massive potential costs.</li>
 	<li>Using the file transfer method(s) that work best for your organization will ensure security compliance and drastically reduce your risk exposure.</li>
</ol>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-1215' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h4 class="nocaps" style="text-align: center;">The VFTP-SSH Collaboration</h4>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' animation='' custom_title_size='18' custom_content_size='14' font_color='' custom_title='' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='nocaps' admin_preview_bg='']
[av_iconlist_item title='Automatic FTP to SFTP Conversion' link='' linktarget='' linkelement='' icon='ue864' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='No JCL Changes' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Secure FTP is Compliance Requirement' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Multi-layered Data Transfer Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Integrate z/OS FTP Server with your SAF for Added Security' link='' linktarget='' linkelement='' icon='ue894' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Visibility of all File Transfers to/from Mainframe' link='' linktarget='' linkelement='' icon='ue804' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3>Featured Presenters:</h3>
<ul>
 	<li><b class="black">Colin van der Ross</b>, Senior Systems Engineer at SDS, will provide several live 2-minute demonstrations of the different solution layers.</li>
 	<li><b class="black">Tim Full</b>, Manager of Tech Services at SDS, provides Pros & Cons along with real-world examples that provide context for the FTP Layers.</li>
</ul>
<h4>Agenda</h4>
There are many methods to consider when trying to find the best solution for your mainframe file transfers.<b class="black">These are the solution layers we’ll focus on during the webinar:</b>
<ul>
 	<li>FTP</li>
 	<li>FTPS (FTP over SSL)</li>
 	<li>FTP over SSH Tunnel</li>
 	<li>SFTP (Secure FTP)</li>
 	<li>FTP to SFTP</li>
 	<li>FTP using <a href="/security-software/e-business-server/">PGP Encryption</a></li>
</ul>
There are significant differences between the methods that can perform mainframe file transfers.  This webinar will help you understand each method’s Pros and Cons and when a given solution can become a security liability.

<hr />

This SHARE webcast is sponsored by Software Diversified Services (SDS) in partnership with SSH Communications Security.
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Peeling the Onion Tutorial</h3>
<h4 class="nocaps" style="text-align: center;">Exploring Viable Means to Perform Secure Mainframe File Transfers</h4>
<p style="text-align: center;">Educational webinar: January 16, 2019</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Introduction to the Peeling the Secure FTP Onion Tutorial</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830279' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">FTP - Layer #1 of the Secure FTP Onion</h4>
<p style="text-align: center;">(6 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830233' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Demonstration of what can go wrong with FTP - Peeling the Secure FTP Onion</h4>
<p style="text-align: center;">(3 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/312778763' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">FTPS (FTP over SSL) - Layer #2 of the Secure FTP Onion</h4>
<p style="text-align: center;">(3 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830314' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">FTP over SSH Tunnel - Layer #3 of the Secure FTP Onion</h4>
<p style="text-align: center;">(2 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830379' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">SFTP (SSH Secure FTP) - Layer #4 of the Secure FTP Onion</h4>
<p style="text-align: center;">(3  minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830598' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Demonstration of SFTP (SSH Secure FTP) in action - Peeling the Secure FTP Onion</h4>
<p style="text-align: center;">(5 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/312778857' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">FTP-SFTP Conversion - Layer #5 of the Secure FTP Onion</h4>
<p style="text-align: center;">(1 minute)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830617' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Demonstration of FTP-SFTP Conversion and how simple it is - Peeling the Secure FTP Onion</h4>
<p style="text-align: center;">(12 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/312778955' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">VPN - Layer #6 of the Secure FTP Onion</h4>
<p style="text-align: center;">(2 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830630' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">PGP Encryption - Layer #7 of the Secure FTP Onion</h4>
<p style="text-align: center;">(3 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830640' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Demonstration of PGP Encryption in action - Peeling the Secure FTP Onion</h4>
<p style="text-align: center;">(4 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/312778807' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Conclusion and Q & A: Peeling the Secure FTP Onion Tutorial</h4>
<p style="text-align: center;">(4 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830690' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Resources' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_portfolio categories='43' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' sort='no' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' id='' custom_class='' av_uid='']

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]";s:13:"0923-vsr-tabs";s:30875:"[av_tab_section tab_pos='av-tab-above-content' tab_arrows='' initial='1' content_height='' tab_padding='default' padding='default' bg_color='' color='' active_color='' color_hover='' active_color_hover='' transition='av-tab-no-transition' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' id='' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_admin_tab_active='1' av_uid='' sc_version='1.0']

[av_tab_sub_section tab_title='Product Details' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps">Easily Transform your 3270 Screens!</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
VSR leverages existing 3270 application screens and converts them into modern and user-friendly Web UIs. But unlike other solutions that rely on server-based Web applications, VSR:
<ul>
 	<li>Is designed to be used by 3270 application developers familiar with the legacy screen UIs and their users; does not require web development skills (HTML5, JS, etc.).</li>
 	<li>Utilizes <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/virtel-web-access/">Virtel Web Access</a>’ infrastructure to serve Web UI pages from the host straight to the user’s Web browser through secure HTTPS connections; does not require TN3270 connections, middle-tier servers, or client applets.</li>
 	<li>Uses automated screen capture, a visual drag-and-drop IDE, reusable screen-to-webpage conversion templates, and integrated widgets to accelerate development.</li>
</ul>
With VSR, you can reap the benefits of modernizing your 3270 user screens without the tremendous costs associated with a full-scale modernization or replacement project. VSR provides a cost-effective way to transform users’ “green screens” quickly and easily without completely overhauling your entire 3270 infrastructure.
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='#ffffff' custom_bg='#525252' custom_border='#525252' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Drag-and-drop interface design' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Customizable widgets' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Use of HTML templates' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Real-time preview capabilities' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_video src='https://vimeo.com/837692551' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<strong>VSR provides a simple, safe, and cost-effective way to rapidly improve your 3270 applications' usability, accessibility, and user experience.</strong>
[/av_textblock]

[/av_one_half][av_one_third first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='0px,30px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='30px,40px,30px,40px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#525252' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Leverage Your 3270 Applications</h4>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Modern and user-friendly web pages are generated <b class="black">from existing 3270 screens</b>. No 3270 application changes or new development is required.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='30px,40px,30px,40px' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#525252' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Leverage VWA Infrastructure</h4>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">The <b class="black">same Virtel Web Access infrastructure</b> used for 3270 terminal emulation serves the host-generated web pages straight to the users’ web browsers. No Telnet, middle-tier servers, or client applets required.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='30px,40px,30px,40px' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#525252' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Leverage 3270 Developers</h4>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Mainframe application developers transfer their <b class="black">understanding of the 3270 screen UIs and users</b> directly into the development of the new web UIs. No web development skills are required.</p>
[/av_textblock]

[/av_one_third][av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='30px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av_uid='']
<h3>Features</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<ul>
 	<li>Converts outdated 3270 screen UIs to modern Web UIs</li>
 	<li>Converts 3270 data entry fields to widgets, when applicable</li>
 	<li>Style is easily changed to meet your corporate standards</li>
 	<li>Works instantly with any Web-enabled client regardless of device, OS, or browser</li>
 	<li>Deploys easily: simply point client web browsers to pre-defined URL</li>
 	<li>Drag-and-drop IDE: no Web development skills or coding required</li>
 	<li>Leverages developers’ understanding of 3270 screen UIs and users</li>
 	<li>Leverages Virtel Web Access (3270 TE) web-to-host infrastructure</li>
 	<li>Supports partial development and deployment for cost-control and earlier ROI</li>
 	<li>No 3270 application changes or new development required</li>
 	<li>No web services development required</li>
 	<li>No middle-tier servers or client applets required</li>
 	<li>Secure end-to-end encrypted HTTPS connections</li>
</ul>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='30px' padding_sync='true' border='' border_color='' radius='5px' radius_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_font_icon icon='ue84b' font='entypo-fontello' style='' caption='' link='' linktarget='' size='40px' position='center' color='#acacac' av_uid=''][/av_font_icon]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#bf1a2d' av_uid='']
<h4 style="text-align: center;">Datasheet</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_button label='Download' icon_select='yes' icon='ue887' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,/productdocs/VSR-datasheet.pdf' link_target='_blank' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='invisible' height='40' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_font_icon icon='ue81f' font='entypo-fontello' style='' caption='' size='40px' position='center' color='#acacac' link='' linktarget='' title_attr='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' animation='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_font_icon]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#bf1a2d' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Request Info</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_button label='Contact Us' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,http://' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-23197' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_third][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section][av_tab_sub_section tab_title='Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section][/av_tab_section]";s:24:"1022-iron-new-features-1";s:2905:"[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='10px,0px' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='#bf1a2d' radius='0px' radius_sync='true' min_col_height='' padding='15px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">IronSphere - Recently Added Features</h3>
[/av_textblock]

[/av_one_full]";s:24:"1022-iron-new-features-2";s:3620:"[av_one_third first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='10px,2%,10px,4%' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='#ffffff' custom_bg='#525252' custom_border='#525252' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='10+ Supplemental Product Packs Available' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_third]";s:24:"1022-iron-new-features-3";s:3642:"[av_one_third min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='10px,2%,10px,4%' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='#ffffff' custom_content='' color='custom' custom_font='#ffffff' custom_bg='#525252' custom_border='#525252' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='iSeries Support Available' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_third]";s:24:"1022-iron-new-features-4";s:3649:"[av_one_third min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='10px,2%,10px,4%' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='#ffffff' custom_content='' color='custom' custom_font='#ffffff' custom_bg='#525252' custom_border='#525252' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Latest STIGs from DISA Available' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='nocaps' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_third]";s:24:"1022-iron-new-features-5";s:4714:"[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='aviaTBcustom_margin' margin='0px,10px' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='#bf1a2d' radius='0px' radius_sync='true' min_col_height='' padding='15px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#f7f7f7' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_button label='Contact SDS for Additional Information' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='0' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_full]";s:13:"1023-bb-after";s:5720:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/file-security-gray-right.jpg' attachment='15792' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;"><b>Peeling the Onion!</b></h2>
<h2 class="nocaps" style="text-align: center;">Exploring Mainframe File Transfer Methods & Best Options for Security</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Watch as we peel back the layers of the SFTP onion.</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23431' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:33:"1023-oniontabs-before-for-newpage";s:38083:"[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='1' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Upcoming Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4>Methods to Securing z/OS File Transfers</h4>
This educational webinar will explore data security on the mainframe, focusing on ways to <a href="/security-software/vftp-ssh/">secure z/OS file transfers</a>.

<strong>Why join us for our updated Peeling the Onion webinar?</strong> <b class="black">It’s as easy as 1 – 2 – 3:</b>
<ol>
 	<li>Your most important and sensitive data is likely housed on your mainframe.</li>
 	<li>Securing that data during transfer isn’t guaranteed and is a crucial compliance mandate with massive potential costs.</li>
 	<li>Using the file transfer method(s) that work best for your organization will ensure security compliance and drastically reduce your risk exposure.</li>
</ol>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://my.demio.com/ref/G9ataDxENvHZM8Vn?source=sdsusa' link_target='_blank' size='large' position='left' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h4 class="nocaps" style="text-align: center;">The VFTP-SSH Collaboration</h4>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' animation='' custom_title_size='18' custom_content_size='14' font_color='' custom_title='' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='nocaps' admin_preview_bg='']
[av_iconlist_item title='Automatic FTP to SFTP Conversion' link='' linktarget='' linkelement='' icon='ue864' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='No JCL Changes' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Secure FTP is Compliance Requirement' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Multi-layered Data Transfer Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Integrate z/OS FTP Server with your SAF for Added Security' link='' linktarget='' linkelement='' icon='ue894' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Visibility of all File Transfers to/from Mainframe' link='' linktarget='' linkelement='' icon='ue804' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Agenda:</h3>
There are many methods to consider when trying to find the best solution for your mainframe file transfers. <b class="black">These are the solution layers we’ll focus on during the webinar:</b>
<ul>
 	<li>FTP</li>
 	<li>FTPS (FTP over SSL)</li>
 	<li>FTP over SSH Tunnel</li>
 	<li>SFTP (Secure FTP)</li>
 	<li>FTP to SFTP</li>
 	<li>FTP using <a href="/security-software/e-business-server/">PGP Encryption</a></li>
</ul>
There are significant differences between the methods that can perform mainframe file transfers.  We will discuss each method’s Pros and Cons and when a given solution can become a security liability.
<h4>Featured Presenters:</h4>
<ul>
 	<li><b class="black">Tim Full</b>, Senior Support Consultant at SDS, provides Pros & Cons along with real-world examples that provide context for the FTP Layers.</li>
 	<li><b class="black">Colin van der Ross</b>, Senior Systems Engineer at SDS, will provide several 2-minute demonstrations of the different solution layers.</li>
</ul>

<hr />

This webinar is sponsored by Software Diversified Services (SDS) in partnership with SSH.com
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Past Webinars' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/mainframe-security-compliance/webinar/security-solutions-for-zos/">Security Solutions for the Mainframe</a></h3>
<h4 class="nocaps" style="text-align: center;">plus an Extended Trial Offer</h4>
<p style="text-align: center;">Our webinar from April 22, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/mainframe-security-compliance/webinar/security-solutions-for-zos/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/mainframe-security-webinar-page-0420.png' attachment='19557' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,19346' target='' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/vftp-ssh/webinar/technology-of-securing-ftp-on-z-os-and-beyond/">Educational Webinar</a>:</h3>
<h4 class="nocaps" style="text-align: center;">Exploring the Technology and Details of Securing FTP on z/OS and Beyond</h4>
<p style="text-align: center;">Our latest VFTP-SSH webinar from October 16, 2019 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/vftp-ssh/webinar/technology-of-securing-ftp-on-z-os-and-beyond/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0' custom_margin_bottom='0' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vftp-ssh-webinar-page-1019.png' attachment='19701' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,19105' target='' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="/security-software/vftp-ssh/webinar/peeling-the-secure-ftp-onion-tutorial/">Peeling the Onion Tutorial</a>:</h3>
<h4 class="nocaps" style="text-align: center;">Exploring Viable Means to Perform Secure Mainframe File Transfers</h4>
<p style="text-align: center;">Our VFTP-SSH webinar from January 16, 2019 is available <a href="/security-software/vftp-ssh/webinar/peeling-the-secure-ftp-onion-tutorial/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0' custom_margin_bottom='0' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vftp-ssh-webinar-page-0119.png' attachment='19703' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,19680' target='' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Peeling the Onion Tutorial</h3>
<h4 class="nocaps" style="text-align: center;">Exploring Viable Means to Perform Secure Mainframe File Transfers</h4>
<p style="text-align: center;">Educational webinar hosted by SHARE: January 16, 2019</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Introduction to the Peeling the Secure FTP Onion Tutorial</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830279' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">FTP - Layer #1 of the Secure FTP Onion</h4>
<p style="text-align: center;">(6 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830233' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Demo of what can go wrong with FTP</h4>
<p style="text-align: center;">(3 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/312778763' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">SFTP (SSH Secure FTP) - Layer #4 of the Secure FTP Onion</h4>
<p style="text-align: center;">(3  minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830598' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Demo of SFTP (SSH Secure FTP) solution in action</h4>
<p style="text-align: center;">(5 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/312778857' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">FTP-SFTP Conversion - Layer #5 of the Secure FTP Onion</h4>
<p style="text-align: center;">(1 minute)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830617' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Demo of FTP-SFTP Conversion and how simple it is</h4>
<p style="text-align: center;">(12 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/312778955' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Conclusion and Q & A: Peeling the Secure FTP Onion Tutorial</h4>
<p style="text-align: center;">(4 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/311830690' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VFTP-SSH Datasheet (opens in a new tab usually), <a href="https://sdsusastg.wpenginepowered.com/productdocs/VFTP-SSH-datasheet.pdf">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VFTP-SSH Resources page, <a href="/security-software/vftp-ssh/resources/">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]";s:28:"1023-sftp-bb-font-right-gray";s:5764:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/file-security-gray-right.jpg' attachment='15792' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;"><b>Peeling the Onion!</b></h2>
<h2 class="nocaps" style="text-align: center;">Exploring Mainframe File Transfer Methods &amp; Best Options for Security</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us on October 4, 2023 at 1:00PM CT as we peel back the layers of the SFTP onion.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,17367' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:37:"1023-sftp-bottom-banner-red-text-left";s:6532:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Peeling the Onion!</h2>
<h2 class="nocaps" style="text-align: center;">Exploring Mainframe File Transfer Methods &amp; Best Options for Security</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us on October 4, 2023 at 1:00PM CT as we peel back the layers of the SFTP onion.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,17367' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/file-security-red-banner.jpg' attachment='15739' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][/av_layout_row]";s:39:"1023-vftp-ssh-last-webinar-page-starter";s:27111:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h1 class="secondary">The VFTP-SSH Collaboration: Secure z/OS FTP | Webinar</h1>
[/av_textblock]

[av_textblock size='20' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="description">Oct. 16, 2019: Exploring the Technology and Details of Securing FTP on z/OS and Beyond</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='1' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Watch Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Educational Webinar:</h3>
<h4 class="nocaps" style="text-align: center;">Exploring the Technology and Details of Securing FTP on z/OS and Beyond</h4>
<p style="text-align: center;">October 16, 2019</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0' custom_margin_bottom='0' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;"><strong>Webinar Preview</strong></h4>
<p style="text-align: center;">(4 min.)</p>
[/av_textblock]

[av_video src='https://vimeo.com/366638287' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' av_uid='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;"><strong>Full-length Webinar</strong></h4>
<p style="text-align: center;">(29 min.)</p>
[/av_textblock]

[av_video src='https://vimeo.com/366606125' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' av_uid='']

[av_button label='Request Access' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='_blank' size='large' position='center' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-17362' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Handouts' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_masonry_gallery ids='1018,15539,17384' items='4' columns='flexible' paginate='none' size='flex' orientation='' gap='large' overlay_fx='active' animation='active' container_links='active' caption_elements='title excerpt' caption_styling='' caption_display='always' color='' custom_bg='' av-medium-columns='' av-small-columns='' av-mini-columns='' id='' custom_class='' av_uid='']

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='Webinar Details' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h4>Secure File Transfers to and from <span class="lower">z</span>/OS</h4>
This educational webinar focuses on transferring data from the mainframe.

We will look into the different scenarios that users face daily when transferring files to a variety of different platforms from z/OS.

For instance, the experts will cover some of the challenges technicians face when transferring data from z/OS to distributed platforms and how to control character conversion, transferring binary files, EOL conversions, and more.
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-1215' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='90%' custom_border_color='#cacaca' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h4 style="padding-top: 20px;">Featured Presenters:</h4>
<b class="black">Jan Hlinovsky</b>, Product Manager, Tectia SSH Server for IBM z/OS, at SSH.com. Jan's presentation will describe the different scenarios encountered by Secure FTP users during their daily jobs.

<b class="black">Colin van der Ross</b>, Senior Systems Engineer at SDS. Colin will provide context for Jan's presentation while demonstrating our<a href="https://sdsusastg.wpenginepowered.com/security-software/vftp-ssh/"> z/OS SFTP solution</a>.
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">VFTP-SSH Benefits</h3>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' animation='' custom_title_size='18' custom_content_size='14' font_color='' custom_title='' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='nocaps' av_uid='' admin_preview_bg='']
[av_iconlist_item title='Automatic FTP to SFTP Conversion' link='' linktarget='' linkelement='' icon='ue864' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='No JCL Changes' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Pass FTP-related Compliance Requirements' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Visibility of all Transfers to/from Mainframe' link='' linktarget='' linkelement='' icon='ue804' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Multi-layered Data Transfer Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Integrate <span class="lower">z</span>/OS FTP Server with your SAF for Added Security' heading_tag='' heading_class='' link='' linktarget='' linkelement='' icon='ue894' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_full first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3>Agenda</h3>
FTP is a readily available, convenient, and inexpensive technology to transfer files and data sets between z/OS and a virtually unlimited number of other operating system platforms. This session will look into different scenarios encountered daily when transferring files from z/OS to different platforms.  We will discuss the following topics in this session.
<ul>
 	<li>SDS and SSH Communications Security backgrounds/focus</li>
 	<li>Different scenarios technicians face daily when transferring files from z/OS to distributed platforms</li>
 	<li>How to control character conversion, transferring binary files, EOL conversions, and more</li>
 	<li>Demonstration of our joint Secure FTP for z/OS solution</li>
 	<li>This demo will focus on some of the scenarios presented earlier</li>
</ul>

<hr />

This webinar is sponsored by Software Diversified Services (SDS) in partnership with <a href="http://www.ssh.com" target="_blank" rel="noopener">SSH.com</a>.
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VFTP-SSH Resources page, <a href="/security-software/vftp-ssh/resources/">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='hidecode' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' id='' custom_class='hide' av_uid='']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="4"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/security-software/vftp-ssh/resources/',
			  '_self'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]
[/av_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-1215' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:31:"1122-vsa-upcoming-bb-text-right";s:4846:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/photo-webinar-security.jpg' attachment='337' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Preparing for Mainframe Security Vulnerabilities</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join Reg Harbeck and Colin van der Ross for an engaging, back-and-forth discussion centered on mainframe security vulnerabilities.  This webinar is hosted by TechChannel.</p>
<p style="text-align: center;"><strong>Thursday, December 1 @ 12:00PM CT</strong></p>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://event.webcasts.com/starthere.jsp?ei=1579841&tp_key=d9fecfd61d&sti=sds&source=sdsusa' link_target='_blank' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:28:"1122-vsa-webinar-details-tab";s:15466:"[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='3' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Watch Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Importance of Delivering Critical z/OS Security Events to your SIEM in Real Time</h3>
<p style="text-align: center;">January 20, 2022</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_video src='https://vimeo.com/668361086' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Handouts' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_masonry_gallery ids='22241,1709,15539' caption_elements='title excerpt' caption_styling='' caption_display='always' size='flex' orientation='' image_size='no scaling' gap='large' columns='flexible' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='' custom_bg='' overlay_fx='active' animation='active' container_links='' link_dest='_blank' lightbox_text='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section][av_tab_sub_section tab_title='Webinar Details' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4>Automatically Deliver z/OS Security Event Records</h4>
This 30-minute webinar will cover:
<ul>
 	<li>Reasons why your organization needs to add z/OS events to your SIEM for security and compliance</li>
 	<li>How VitalSigns SIEM Agent for z/OS is positioned to fill this need</li>
 	<li>A demonstration using VSA and an enterprise SIEM (Splunk) in tandem</li>
</ul>
<strong>We hope you can join us for this webinar on Thursday, January 20 at 1:00PM CT.</strong>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-1664' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='90%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Featured Presenter:</h3>
<ul>
 	<li><b class="black">Colin van der Ross</b>, Sr. Systems Engineer at Software Diversified Services, has a wide range of experience working with TCP/IP, network management, security, and network performance solutions. Colin has been with SDS for over a decade and in the field for another 20+ years.</li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h5 class="nocaps" style="text-align: center;">VitalSigns SIEM Agent for z/OS</h5>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='14' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='' custom_bg='#bf1a2d' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='nocaps' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Real-Time Delivery of Important z/OS Event Records to SIEM' link='' linktarget='' linkelement='' icon='ue862' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Automates z/OS Event Logging Process' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Helps Achieve Security Compliance for Z' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Alerts when Threat/Breach is Detected' link='' linktarget='' linkelement='' icon='ue83d' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Integrates well with any SIEM' link='' linktarget='' linkelement='' icon='ue8ce' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Filters out Noise, Saving Resources' link='' linktarget='' linkelement='' icon='ue85f' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Abstract</h3>
Is your shop properly leveraging all the z/OS security event logs at your disposal? The sheer volume of records demands the implementation of a reliable solution to make sense of the data and send alerts when a potential serious security incident has occurred.

Let VitalSigns SIEM Agent for z/OS (VSA) automate and simplify this task.

VSA has hundreds of filtering options, allowing the user to customize what needs to be delivered to their existing SIEM product. Once setup is complete, VSA will automatically filter out the noise and deliver the important event records to any SIEM in real time. VSA and its granular filtering produce fewer false alarms and lower SIEM license charges than you would see with competing event log forwarders.

This 30-minute webinar will cover:
<ul>
 	<li>Reasons why your organization needs to add z/OS events to your SIEM for security and compliance</li>
 	<li>Explore why VitalSigns SIEM Agent for z/OS is uniquely positioned to fill this need</li>
 	<li>Provide new features and capabilities in VSA 4.2</li>
 	<li>A demonstration using VSA and an enterprise SIEM (Splunk) in tandem</li>
</ul>

<hr />

This webinar is sponsored by Software Diversified Services (SDS).
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_portfolio categories='47' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' sort='no' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' lazy_loading='disabled' id='' custom_class='' av_uid='']

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]";s:34:"1122-vsa-webinar-tabs-post-webinar";s:29756:"[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='1' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Past Webinars' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/delivering-critical-z-os-security-events-to-your-siem-in-real-time/">Importance of Delivering Critical z/OS Security Events to your SIEM in Real Time</a></h3>
<p style="text-align: center;">Our latest VSA webinar from January 20, 2022 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/delivering-critical-z-os-security-events-to-your-siem-in-real-time/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-0122.png' attachment='22250' attachment_size='full' copyright='' caption='' image_size='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,22240' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/automatically-deliver-filtered-z-os-security-event-records-to-siem/">Automatically Deliver z/OS Security Events to your SIEM</a></h3>
<p style="text-align: center;">Our VSA webinar from November 18, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/automatically-deliver-filtered-z-os-security-event-records-to-siem/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-1120.png' attachment='20730' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,20654' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/mainframe-security-compliance/webinar/security-solutions-for-zos/">Security Solutions for the Mainframe</a></h3>
<h4 class="nocaps" style="text-align: center;">plus an Extended Trial Offer</h4>
<p style="text-align: center;">Our webinar from April 22, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/mainframe-security-compliance/webinar/security-solutions-for-zos/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/mainframe-security-webinar-page-0420.png' attachment='19847' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,19346' target='' title_attr='' alt_attr='' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="/security-software/mainframe-siem/webinar/fill-your-security-monitoring-gap/">Fill your Mainframe Security Monitoring Gap via SIEM</a></h3>
<h4 class="nocaps" style="text-align: center;">& Custom, Granular Filtering</h4>
<p style="text-align: center;">Our VSA webinar from September 19, 2019 is available <a href="/security-software/mainframe-siem/webinar/fill-your-security-monitoring-gap/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0' custom_margin_bottom='0' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-092019.jpg' attachment='20791' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,19202' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Add Real-Time, Critical Mainframe Events to your SIEM</h3>
<h4 class="nocaps" style="text-align: center;">with VitalSigns SIEM Agent for z/OS</h4>
<p style="text-align: center;">November 14, 2018</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Benefits of being able to incorporate Real-Time z/OS Events into your SIEM tool</h4>
<p style="text-align: center;">(7 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/301007072' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Key Things to Consider related to Filtering & Delivering z/OS Events to SIEM</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/301007180' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">VSA Overview and Features that provide Real-Time Visibility/Alerts, and more</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/301097740' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Product Demonstration: Watch as VSA delivers z/OS Events into QRadar</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/300932649' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">A Question and Answer Session that provides 3 Answers to 3 Common Questions</h4>
<p style="text-align: center;">(3 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/300934728' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VSA Datasheet (opens in a new tab usually), <a href="https://sdsusastg.wpenginepowered.com/productdocs/VSA-datasheet.pdf">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VSA Resources page, <a href="/security-software/mainframe-siem/resources/">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]";s:25:"1122-vsa-webinar-upcoming";s:5046:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Preparing for Mainframe Security Vulnerabilities</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join Reg Harbeck and Colin van der Ross for an engaging, back-and-forth discussion centered on mainframe security vulnerabilities.  This webinar is hosted by TechChannel.</p>
<p style="text-align: center;"><strong>Thursday, December 1 @ 12:00PM CT</strong></p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,1699' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/tablet-gray-left.jpg' attachment='20833' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][/av_layout_row]";s:27:"1123-bb-vsa-font-right-gray";s:5683:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Understanding Potential Savings with zIIP Offload and VitalSigns SIEM Agent for z/OS 4.3</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us for this 30-minute webinar on Thursday, November 16 at 1:00PM CT.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,1699' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:15:"1123-bb-vsa-red";s:6456:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Understanding Potential Savings with zIIP Offload and VitalSigns SIEM Agent for z/OS 4.3</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us for this 30-minute webinar on Thursday, November 16 at 1:00PM CT.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,1699' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/tablet-red-banner.jpg' attachment='15858' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][/av_layout_row]";s:21:"1123-new-webinar-page";s:27582:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='#acacac' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' custom_class='' av_uid='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h1 class="secondary">
VitalSigns SIEM Agent™ for z/OS | VSA | Webinar</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='20' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">December 1, 2022: Preparing For Mainframe Security Vulnerabilities</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='av-hide-on-mobile' custom_class='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' custom_class='' av_uid=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='2' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Watch Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Preparing for Mainframe Security Vulnerabilities</h3>
<p style="text-align: center;">December 1, 2022</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_video src='https://vimeo.com/778090991' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Handouts' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_masonry_gallery ids='22800,1709' caption_elements='title excerpt' caption_styling='' caption_display='always' size='flex' orientation='' image_size='no scaling' gap='large' columns='flexible' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='' custom_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='_blank' lightbox_text='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section][av_tab_sub_section tab_title='Webinar Details' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_three_fifth first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4><span class="lower">z</span>/OS security event logs should be leveraged, not overlooked</h4>
This webinar was hosted by <a href="https://techchannel.com/Webinars" target="_blank" rel="noopener">TechChannel</a>.

Join Reg Harbeck and Colin van der Ross for an engaging, back-and-forth discussion centered on mainframe security vulnerabilities.  Both current and future security risks will be explored along with an SDS solution that is a powerful tool to help protect your organization.
<ul>
 	<li>Exploring mainframe vulnerabilities – now and in the future.
<ul>
 	<li>Can a mainframe be hacked?</li>
</ul>
</li>
 	<li>The value of including the mainframe into your security information and event management (SIEM) strategy.</li>
 	<li>What should be sent to the SIEM? Our z/OS security event recommendations.
<ul>
 	<li>Demonstrate how <a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/">VitalSigns SIEM Agent for z/OS</a> delivers z/OS security events to any SIEM in real-time.</li>
</ul>
</li>
</ul>
<strong>We're thankful so many of you joined us for the webinar. We really appreciate it.</strong>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='_blank' size='large' position='left' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-1664' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='90%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Featured Presenters:</h3>
<ul>
 	<li><b class="black">Reg Harbeck</b>, Chief Strategist at Mainframe Analytics, Ltd.</li>
 	<li><b class="black">Colin van der Ross</b>, Sr. Systems Engineer at Software Diversified Services.</li>
</ul>
[/av_textblock]

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h5 class="nocaps" style="text-align: center;">VitalSigns SIEM Agent for z/OS</h5>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='14' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='' custom_bg='#bf1a2d' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='nocaps' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Real-Time Delivery of Important Mainframe Event Records to SIEM' icon='ue862' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Automates Mainframe Event Logging Process' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Helps Achieve Security Compliance for Z' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Alerts when Threat/Breach is Detected' link='' linktarget='' linkelement='' icon='ue83d' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Integrates well with any SIEM' link='' linktarget='' linkelement='' icon='ue8ce' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Filters out Noise, Saving Resources' link='' linktarget='' linkelement='' icon='ue85f' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_two_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VSA Resources page, <a href="/security-software/mainframe-siem/resources/">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='hidecode' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' alb_description='' id='' custom_class='hide' template_class='' av_uid='' sc_version='1.0']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="4"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/resources/',
			  '_self'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]
[/av_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-1664' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:31:"1123-vsa-bb-after-text-left-red";s:6503:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Understanding Potential Savings with zIIP Offload and VitalSigns SIEM Agent for z/OS 4.3</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">This 30-minute webinar is available for you to watch right now.  We'd love to hear from you with any questions you may have!</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23513' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/tablet-red-banner.jpg' attachment='15858' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][/av_layout_row]";s:20:"1123-vsa-webinar-tab";s:46205:"[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='1' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Upcoming Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4><span class="lower">z</span>IIP Offload can be leveraged with VSA for significant savings</h4>
Everyone is welcome. We encourage both current customers and anyone interested in VSA to join us for this 30-minute webinar.  Here's the agenda:
<ul>
 	<li>What’s new in VSA 4.3, focusing on zIIP offload</li>
 	<li>zIIP offload overview and eligibility</li>
 	<li>Discuss VSA 4.3 zIIP offload performance benchmark test results</li>
 	<li>Customer feedback and wrap-up</li>
</ul>
<strong>Join us for this webinar on Thursday, November 16 at 1:00PM CT.</strong>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://my.demio.com/ref/oxW4ENUf1csTaAd4' link_target='_blank' size='large' position='left' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='90%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Featured Presenters:</h3>
<ul>
 	<li><b class="black">Colin van der Ross</b>, Senior Systems Engineer at SDS, will discuss new zIIP offload capabilities of VSA and the results of VSA performance tests.</li>
 	<li><b class="black">Lori Kettles</b>, Sales Manager at SDS, will be the host and provide the introduction and conclusion.</li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h5 class="nocaps" style="text-align: center;">VitalSigns SIEM Agent for z/OS</h5>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='14' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='' custom_bg='#bf1a2d' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='nocaps' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Real-Time Delivery of Important z/OS Event Records to SIEM' link='' linktarget='' linkelement='' icon='ue862' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Automates z/OS Event Logging Process' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Helps Achieve Security Compliance for Z' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Alerts when Threat/Breach is Detected' link='' linktarget='' linkelement='' icon='ue83d' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Integrates well with any SIEM' link='' linktarget='' linkelement='' icon='ue8ce' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Filters out Noise, Saving Resources' link='' linktarget='' linkelement='' icon='ue85f' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Past Webinars' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/preparing-for-mainframe-security-vulnerabilities/">Preparing for Mainframe Security Vulnerabilities</a></h3>
<p style="text-align: center;">Our latest VSA webinar from December 1, 2022 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/preparing-for-mainframe-security-vulnerabilities/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-1222.jpg' attachment='22808' attachment_size='full' copyright='' caption='' image_size='' styling='no-styling' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='av-hover-grow' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' link='page,22788' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/delivering-critical-z-os-security-events-to-your-siem-in-real-time/">Importance of Delivering Critical z/OS Security Events to your SIEM in Real Time</a></h3>
<p style="text-align: center;">Our VSA webinar from January 20, 2022 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/delivering-critical-z-os-security-events-to-your-siem-in-real-time/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-0122.png' attachment='22250' attachment_size='full' copyright='' caption='' image_size='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,22240' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/automatically-deliver-filtered-z-os-security-event-records-to-siem/">Automatically Deliver z/OS Security Events to your SIEM</a></h3>
<p style="text-align: center;">Our VSA webinar from November 18, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/automatically-deliver-filtered-z-os-security-event-records-to-siem/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-1120.png' attachment='20730' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,20654' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/mainframe-security-compliance/webinar/security-solutions-for-zos/">Security Solutions for the Mainframe</a></h3>
<h4 class="nocaps" style="text-align: center;">plus an Extended Trial Offer</h4>
<p style="text-align: center;">Our webinar from April 22, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/mainframe-security-compliance/webinar/security-solutions-for-zos/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/mainframe-security-webinar-page-0420.png' attachment='19847' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,19346' target='' title_attr='' alt_attr='' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="/security-software/mainframe-siem/webinar/fill-your-security-monitoring-gap/">Fill your Mainframe Security Monitoring Gap via SIEM</a></h3>
<h4 class="nocaps" style="text-align: center;">& Custom, Granular Filtering</h4>
<p style="text-align: center;">Our VSA webinar from September 19, 2019 is available <a href="/security-software/mainframe-siem/webinar/fill-your-security-monitoring-gap/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0' custom_margin_bottom='0' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-092019.jpg' attachment='20791' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,19202' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Add Real-Time, Critical Mainframe Events to your SIEM</h3>
<h4 class="nocaps" style="text-align: center;">with VitalSigns SIEM Agent for z/OS</h4>
<p style="text-align: center;">November 14, 2018</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Benefits of being able to incorporate Real-Time z/OS Events into your SIEM tool</h4>
<p style="text-align: center;">(7 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/301007072' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Key Things to Consider related to Filtering & Delivering z/OS Events to SIEM</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/301007180' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">VSA Overview and Features that provide Real-Time Visibility/Alerts, and more</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/301097740' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Product Demonstration: Watch as VSA delivers z/OS Events into QRadar</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/300932649' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">A Question and Answer Session that provides 3 Answers to 3 Common Questions</h4>
<p style="text-align: center;">(3 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/300934728' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VSA Datasheet (opens in a new tab usually), <a href="https://sdsusastg.wpenginepowered.com/productdocs/VSA-datasheet.pdf">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VSA Resources page, <a href="/security-software/mainframe-siem/resources/">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]";s:24:"1123vsa-webinar-bb-after";s:5742:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/tablet-gray-right.jpg' attachment='15848' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Understanding Potential Savings with zIIP Offload and VitalSigns SIEM Agent for z/OS 4.3</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">This 30-minute webinar is available for you to watch right now.  We'd love to hear from you with any questions you may have!</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23513' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:20:"1124-iron-learn-more";s:4505:"[av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='5px' radius_sync='true' min_col_height='' padding='0px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Learn More</h3>
[/av_textblock]

[av_masonry_gallery ids='23928,23931,23930,23929' caption_elements='title' caption_styling='' caption_display='always' img_copyright='' size='flex' orientation='' image_size='no scaling' gap='large' columns='2' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='custom' custom_bg='#e8e8e8' img_copyright_font='' av-desktop-font-img_copyright_font='' av-medium-font-img_copyright_font='' av-small-font-img_copyright_font='' av-mini-font-img_copyright_font='' img_copyright_color='' img_copyright_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='' lightbox_text='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='masonwborders' template_class='' av_uid='' sc_version='1.0']
[/av_three_fifth]";s:30:"1222-vsa-bb-after-content-left";s:5023:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Preparing for Mainframe Security Vulnerabilities</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Reg Harbeck and Colin van der Ross engage in a back-and-forth discussion centered on mainframe security vulnerabilities. They discuss what to prepare against and how to protect your organization. This webinar is hosted by TechChannel.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,1699' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/tablet-gray-left.jpg' attachment='20833' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][/av_layout_row]";s:25:"1222-vsa-webinar-bb-after";s:5013:"[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Preparing for Mainframe Security Vulnerabilities</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Reg Harbeck and Colin van der Ross engage in a back-and-forth discussion centered on mainframe security vulnerabilities. They discuss what to prepare against and how to protect your organization. This webinar is hosted by TechChannel.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,22788' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][/av_layout_row]";s:25:"1222-vsa-webinar-forafter";s:50562:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='#acacac' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' custom_class='' av_uid='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h1 class="secondary">
VitalSigns SIEM Agent™ for z/OS | VSA | Webinar</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='20' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">December 1, 2022 at 12:00PM CT: Preparing For Mainframe Security Vulnerabilities</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='av-hide-on-mobile' custom_class='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' custom_class='' av_uid=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='1' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Webinar Details' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4><span class="lower">z</span>/OS security event logs should be leveraged, not overlooked</h4>
This webinar will be hosted by <a href="https://event.webcasts.com/starthere.jsp?ei=1579841&tp_key=d9fecfd61d&sti=sds" target="_blank" rel="noopener">TechChannel</a>. The agenda will be:
<ul>
 	<li>Exploring mainframe vulnerabilities – now and in the future.
<ul>
 	<li>Can a mainframe be hacked?</li>
</ul>
</li>
 	<li>The value of including the mainframe into your security information and event management (SIEM) strategy.</li>
 	<li>What should be sent to the SIEM? Our z/OS security event recommendations.
<ul>
 	<li>Demonstrate how <a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/">VitalSigns SIEM Agent for z/OS</a> delivers z/OS security events to any SIEM in real-time.</li>
</ul>
</li>
</ul>
<strong>Join us for this webinar on Thursday, December 1 at 12:00PM CT.</strong>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://event.webcasts.com/starthere.jsp?ei=1579841&tp_key=d9fecfd61d&sti=sds&source=sdsusa' link_target='_blank' size='large' position='left' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='90%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Featured Presenters:</h3>
<ul>
 	<li><b class="black">Reg Harbeck</b>, Chief Strategist at Mainframe Analytics, Ltd.</li>
 	<li><b class="black">Colin van der Ross</b>, Sr. Systems Engineer at Software Diversified Services.</li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h5 class="nocaps" style="text-align: center;">VitalSigns SIEM Agent for z/OS</h5>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='14' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='' custom_bg='#bf1a2d' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='nocaps' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Real-Time Delivery of Important z/OS Event Records to SIEM' link='' linktarget='' linkelement='' icon='ue862' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Automates z/OS Event Logging Process' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Helps Achieve Security Compliance for Z' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Alerts when Threat/Breach is Detected' link='' linktarget='' linkelement='' icon='ue83d' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Integrates well with any SIEM' link='' linktarget='' linkelement='' icon='ue8ce' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Filters out Noise, Saving Resources' link='' linktarget='' linkelement='' icon='ue85f' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Add Real-Time, Critical Mainframe Events to your SIEM</h3>
<h4 class="nocaps" style="text-align: center;">with VitalSigns SIEM Agent for z/OS</h4>
<p style="text-align: center;">November 14, 2018</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Benefits of being able to incorporate Real-Time z/OS Events into your SIEM tool</h4>
<p style="text-align: center;">(7 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/301007072' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Key Things to Consider related to Filtering & Delivering z/OS Events to SIEM</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/301007180' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">VSA Overview and Features that provide Real-Time Visibility/Alerts, and more</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/301097740' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Product Demonstration: Watch as VSA delivers z/OS Events into QRadar</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/300932649' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">A Question and Answer Session that provides 3 Answers to 3 Common Questions</h4>
<p style="text-align: center;">(3 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/300934728' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Past Webinars' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/delivering-critical-z-os-security-events-to-your-siem-in-real-time/">Importance of Delivering Critical z/OS Security Events to your SIEM in Real Time</a></h3>
<p style="text-align: center;">Our latest VSA webinar from January 20, 2022 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/delivering-critical-z-os-security-events-to-your-siem-in-real-time/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-0122.png' attachment='22250' attachment_size='full' copyright='' caption='' image_size='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,22240' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/automatically-deliver-filtered-z-os-security-event-records-to-siem/">Automatically Deliver z/OS Security Events to your SIEM</a></h3>
<p style="text-align: center;">Our VSA webinar from November 18, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/webinar/automatically-deliver-filtered-z-os-security-event-records-to-siem/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-1120.png' attachment='20730' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,20654' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/mainframe-security-compliance/webinar/security-solutions-for-zos/">Security Solutions for the Mainframe</a></h3>
<h4 class="nocaps" style="text-align: center;">plus an Extended Trial Offer</h4>
<p style="text-align: center;">Our webinar from April 22, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/mainframe-security-compliance/webinar/security-solutions-for-zos/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/mainframe-security-webinar-page-0420.png' attachment='19847' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,19346' target='' title_attr='' alt_attr='' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30' custom_margin_bottom='30' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="/security-software/mainframe-siem/webinar/fill-your-security-monitoring-gap/">Fill your Mainframe Security Monitoring Gap via SIEM</a></h3>
<h4 class="nocaps" style="text-align: center;">& Custom, Granular Filtering</h4>
<p style="text-align: center;">Our VSA webinar from September 19, 2019 is available <a href="/security-software/mainframe-siem/webinar/fill-your-security-monitoring-gap/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0' custom_margin_bottom='0' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/vsa-webinar-page-092019.jpg' attachment='20791' attachment_size='full' copyright='' caption='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,19202' target='' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VSA Datasheet (opens in a new tab usually), <a href="https://sdsusastg.wpenginepowered.com/productdocs/VSA-datasheet.pdf">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the VSA Resources page, <a href="/security-software/mainframe-siem/resources/">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='hidecode' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' alb_description='' id='' custom_class='hide' template_class='' av_uid='' sc_version='1.0']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="4"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/productdocs/VSA-datasheet.pdf',
			  '_blank'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' alb_description='' id='' custom_class='hide' template_class='' av_uid='' sc_version='1.0']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="5"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/security-software/mainframe-siem/resources/',
			  '_self'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]
[/av_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-1664' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:21:"1222-vsa-webinar-tabs";s:15466:"[av_tab_section transition='av-tab-no-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='3' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Watch Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Importance of Delivering Critical z/OS Security Events to your SIEM in Real Time</h3>
<p style="text-align: center;">January 20, 2022</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_video src='https://vimeo.com/668361086' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Handouts' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_masonry_gallery ids='22241,1709,15539' caption_elements='title excerpt' caption_styling='' caption_display='always' size='flex' orientation='' image_size='no scaling' gap='large' columns='flexible' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='' custom_bg='' overlay_fx='active' animation='active' container_links='' link_dest='_blank' lightbox_text='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section][av_tab_sub_section tab_title='Webinar Details' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4>Automatically Deliver z/OS Security Event Records</h4>
This 30-minute webinar will cover:
<ul>
 	<li>Reasons why your organization needs to add z/OS events to your SIEM for security and compliance</li>
 	<li>How VitalSigns SIEM Agent for z/OS is positioned to fill this need</li>
 	<li>A demonstration using VSA and an enterprise SIEM (Splunk) in tandem</li>
</ul>
<strong>We hope you can join us for this webinar on Thursday, January 20 at 1:00PM CT.</strong>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-1664' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='90%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Featured Presenter:</h3>
<ul>
 	<li><b class="black">Colin van der Ross</b>, Sr. Systems Engineer at Software Diversified Services, has a wide range of experience working with TCP/IP, network management, security, and network performance solutions. Colin has been with SDS for over a decade and in the field for another 20+ years.</li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h5 class="nocaps" style="text-align: center;">VitalSigns SIEM Agent for z/OS</h5>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='14' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='' custom_bg='#bf1a2d' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='nocaps' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Real-Time Delivery of Important z/OS Event Records to SIEM' link='' linktarget='' linkelement='' icon='ue862' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Automates z/OS Event Logging Process' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Helps Achieve Security Compliance for Z' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Alerts when Threat/Breach is Detected' link='' linktarget='' linkelement='' icon='ue83d' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Integrates well with any SIEM' link='' linktarget='' linkelement='' icon='ue8ce' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Filters out Noise, Saving Resources' link='' linktarget='' linkelement='' icon='ue85f' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Abstract</h3>
Is your shop properly leveraging all the z/OS security event logs at your disposal? The sheer volume of records demands the implementation of a reliable solution to make sense of the data and send alerts when a potential serious security incident has occurred.

Let VitalSigns SIEM Agent for z/OS (VSA) automate and simplify this task.

VSA has hundreds of filtering options, allowing the user to customize what needs to be delivered to their existing SIEM product. Once setup is complete, VSA will automatically filter out the noise and deliver the important event records to any SIEM in real time. VSA and its granular filtering produce fewer false alarms and lower SIEM license charges than you would see with competing event log forwarders.

This 30-minute webinar will cover:
<ul>
 	<li>Reasons why your organization needs to add z/OS events to your SIEM for security and compliance</li>
 	<li>Explore why VitalSigns SIEM Agent for z/OS is uniquely positioned to fill this need</li>
 	<li>Provide new features and capabilities in VSA 4.2</li>
 	<li>A demonstration using VSA and an enterprise SIEM (Splunk) in tandem</li>
</ul>

<hr />

This webinar is sponsored by Software Diversified Services (SDS).
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_portfolio categories='47' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' sort='no' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' lazy_loading='disabled' id='' custom_class='' av_uid='']

[/av_one_full][/av_tab_sub_section]
[/av_tab_section]";s:26:"1223-vws-category-grouping";s:7520:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='av-break-at-tablet' av_uid='' custom_class='']

[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-application-access.png' attachment='375' attachment_size='full' align='center' styling='no-styling' hover='' link='page,101' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/application-access-modernization/">Application Access & Modernization</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<table class="e8e8e8gray3">
<tbody>
<tr>
<td><a href="/application-access-modernization/virtel-web-access/">Virtel<sup>®</sup> Web Access</a></td>
<td>Ultra-thin and secure 3270 TE on any device</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-web-modernization/">Virtel<sup>®</sup> Web Modernization</a></td>
<td>Serve host transactions as user-friendly web pages (GUIs)</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-web-integration/">Virtel<sup>®</sup> Web Integration</a></td>
<td>Create interactive bidirectional connections; integrate host &amp; web</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-screen-redesigner/">Virtel<sup>®</sup> Screen Redesigner</a></td>
<td>Create modern and user-friendly web UIs from your existing legacy 3270 screens</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#cacaca' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-cics.png' attachment='374' attachment_size='full' align='center' styling='no-styling' hover='' link='page,99' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/cics-management/">CICS Management</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="cacacagray3">
<tbody>
<tr>
<td><a href="/cics-management/cafc/">CAFC<sup>™</sup></a></td>
<td>CICS Application File Control system software</td>
</tr>
<tr>
<td><a href="/cics-management/ipcp-plus/">IPCP<sup>™</sup> Plus for z/OS & z/VSE</a></td>
<td>Premier file control utility for z/OS & z/VSE</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#f7f7f7' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-security.png' attachment='371' attachment_size='full' align='center' styling='no-styling' hover='' link='page,16088' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='fade-in' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_textblock size='' font_color='custom' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/encryption-ssh-solutions/">Encryption & SSH Solutions</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<table class="f7f7f7gray3">
<tbody>
<tr>
<td><a href="/security-software/e-business-server/">SDS E-Business Server<sup>®</sup></a></td>
<td>Multi-platform PGP encryption for data at rest</td>
</tr>
<tr>
<td><a href="/security-software/tectia-ssh/">Tectia<sup>®</sup> SSH</a></td>
<td>Server and client that secures and encrypts file transfers and more</td>
</tr>
<tr>
<td><a href="/security-software/universal-ssh-key-manager/">Universal SSH Key Manager<sup>®</sup></a></td>
<td>Centralize, simplify, and automate SSH key management</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][/av_layout_row]";s:25:"2022-ironsphere-main-page";s:50499:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='#acacac' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' custom_class='' av_uid='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h1 class="secondary">SDS IronSphere for z/OS</h1>
[/av_textblock]

[av_textblock size='20' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="description">Automated DISA STIG compliance monitoring for z/OS.</h2>
<h2 class="description">Real-time, continuous mainframe security monitoring and auditing.</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='3px,0px,0px,0px' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='av-hide-on-mobile' custom_class='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' custom_class='' av_uid=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-slide-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='6' bg_color='#7f7f7f' color='#ffffff' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Product Details' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,30px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Real-Time <span class="lower">z</span>/OS Risk Awareness</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
This continuous monitoring solution can further strengthen even the most secure mainframe. <em>SDS IronSphere for z/OS also provides assistance for, while complying with, standards that U.S. Federal Government agencies are required to follow</em>. <b>Automatic z/OS STIG compliance monitoring is a major highlight</b>, but IronSphere offers many more security compliance features for the mainframe.
<h4 class="nocaps">IronSphere for z/OS follows Frameworks and Guidelines</h4>
This tool was created by mainframe penetration testers and compliance-minded, security experts. Due to their experience in the field, IronSphere for z/OS follows the guidelines that play integral roles in the framework of security compliance mandates and are required to be followed within certain sectors.
<h4 class="nocaps">IronSphere provides Mainframe Compliance Assistance by:</h4>
<ul>
 	<li><b class="black">Adhering to <a href="https://www.nist.gov/publications/information-security-continuous-monitoring-iscm-federal-information-systems-and" target="win2">NIST ISCM</a></b> (<em>Information Security Continuous Monitoring</em>) Guidelines</li>
 	<li><b class="black">Following <a href="https://www.nist.gov/cyberframework" target="win2">NIST CSF</a></b> (Cybersecurity Framework)</li>
 	<li><b class="black">Following <a href="https://csrc.nist.gov/projects/risk-management/risk-management-framework-(rmf)-overview" target="win2">RMF</a></b> (<em>Risk Management Framework</em>)</li>
 	<li><b class="black">Automatically running security diagnostic scans based on <a href="https://www.disa.mil/" target="win2">DISA</a></b> (<em>Defense Information Systems Agency</em>) <b><a href="https://iase.disa.mil/stigs/Pages/index.aspx" target="win2">STIGs</a></b> (<em>Security Technical Implementation Guides</em>) - Compliance to DISA STIGs is a DoD requirement</li>
</ul>
This tool also assists in complying with many additional standards (GDPR, FISMA, etc.) by following above frameworks.
<h4 class="nocaps">How will IronSphere help your Organization?</h4>
This solution <b class="black">automatically and continuously identifies system risks, then delivers easy-to-follow remediation steps</b> as part of the assessment results. In addition, results are kept within the tool, proving to compliance auditors that you've been continuously monitoring your z/OS system and adhering to ISCM and RMF protocols.

This mainframe solution offers a new level of system visibility by <b class="black">displaying z/OS scan results and system vulnerabilities in a GUI with a "40,000 foot view"</b> for specialized experts within the Security and GRC Teams, Upper-Level Managers, and the z/OS Mainframe Team. The display also contains more details to satisfy and guide z/OS team members charged with implementing the fixes detailed in the guides.

<strong>Automate z/OS STIG compliance and add security with IronSphere.</strong>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='left' label_display='' title_attr='' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][av_one_half min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,25px' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_video src='https://vimeo.com/showcase/5300985' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">IronSphere for z/OS - Key Benefits</h3>
<h4 class="nocaps" style="text-align: center;">Simplify z/OS Security Compliance by Automating STIGs</h4>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' animation='' alb_description='' id='' custom_class='nocaps' av_uid='' admin_preview_bg='']
[av_iconlist_item title='Stronger, Standards-based Mainframe Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Automate Tedious <span class="lower">z</span>/OS STIG Process' icon='ue864' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid=''][/av_iconlist_item]
[av_iconlist_item title=' More Manageable Compliance Mandates' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Find & Display Security Vulnerabilities' link='' linktarget='' linkelement='' icon='ue8de' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Simple Risk Remediation Steps Provided' link='' linktarget='' linkelement='' icon='ue84b' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[av_iconlist_item title='Help for Auditors; Painless Future Audits' link='' linktarget='' linkelement='' icon='ue803' font='entypo-fontello' av_uid='' heading_tag='' heading_class=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_two_third first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='0px,15px' mobile_breaking='' border='1' border_color='#bf1a2d' radius='0px' radius_sync='true' padding='15px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Additional Checks and Flexibility</h4>
Many z/OS components lacking DISA STIGs already have their own checks created on the IronSphere system and can be made available to users. <b class="black">If you need another set of checks, simply request it and it'll be configured ASAP</b>.

Also, some organizations may require even more flexibility. <b class="black">New checks can be created by your team, tailored to fit your needs, and implemented within the product.</b> With these new checks and the power of IronSphere, you have the ability to setup acceptable limits and standards for your mainframe components not covered by a DISA STIG.

Just like any typical component with a DISA STIG on IronSphere, security vulnerabilities and remediation steps are provided after running these checks is complete.
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/DBTA-TSP-2021-logo.png' attachment='20812' attachment_size='full' copyright='' caption='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='' appearance='' link='manually,https://www.dbta.com/Editorial/Trends-and-Applications/Trend-Setting-Products-in-Data-and-Information-Management-for-2021-144175.aspx' target='_blank' title_attr='' alt_attr='' lazy_loading='disabled' id='' custom_class='' av_element_hidden_in_editor='0' av_uid='' admin_preview_bg=''][/av_image]

[/av_one_third][av_one_third first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='0px,30px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='30px,40px,30px,40px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' av_uid='']
<h4 style="text-align: center;">Compliance</h4>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">This z/OS security tool will reduce workload required to comply with government regulatory standards as compliance was major focus during development. IronSphere can help become compliant with NIST ISCM, FISMA, GDPR, and others; it uses DISA STIGs and can facilitate Risk Management Framework implementation on the mainframe.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='30px,40px,30px,40px' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' custom_class='' av_uid='']
<h4 style="text-align: center;">GUI Display</h4>
[/av_textblock]

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<p style="text-align: center;">Mainframe expertise is not required to view and understand the system's risks and the course of action that must be followed to resolve them!  The GUI provides an opportunity for those outside of the mainframe world to have visibility into this critical system and its vulnerabilities.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='30px,40px,30px,40px' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' custom_class='' av_uid='']
<h4 style="text-align: center;">Security</h4>
[/av_textblock]

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<p style="text-align: center;">IronSphere has the ability to provide additional mainframe security on top of your already hardened system! It does this by identifying vulnerabilities and system issues through continuous monitoring. Following standards and all best practices will result in achieving an unthinkable level of z/OS security and smooth audits.</p>
[/av_textblock]

[/av_one_third][av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='30px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' font_color='' color='' av_uid='']
<h3>Features</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li>An ISCM, RMF-based tool that continuously monitors the mainframe on an optimal schedule</li>
 	<li>Real-time z/OS monitoring helps protect data, achieve top-level security, comply with standards</li>
 	<li>Helps pass security compliance protocols for z/OS: NIST ISCM, DISA, FISMA, GDPR, & more</li>
 	<li>GRC for z/OS solution; ideal for many industries: government, financial, insurance</li>
 	<li>Doesn't require z/OS expertise to interpret results in GUI; additional fix information for z/OS Team</li>
 	<li>Provides a single point of reporting for mainframe system health and risks to the system</li>
 	<li>Saves resources via automatic delivery of DISA STIGs for required system software updates</li>
 	<li>Lowers overhead and lessens reliance on scarce, experienced mainframe experts; better use of experts</li>
 	<li>Lean agent gathers data on mainframe efficiently, leaves no trace behind</li>
 	<li>Flexible solution: define user roles, create your own system checks/STIGs, and can configure other settings</li>
 	<li>Runs on many mainframe operating systems: z/OS, Linux on IBM Z, z/VSE, z/VM, z/TPF, AS/400</li>
 	<li>Enhanced security, advanced breach avoidance, compliance for large organizations</li>
 	<li>Helps smaller z/OS shops with best practices, heightened security, lower costs through automatic process</li>
</ul>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='30px' padding_sync='true' border='' border_color='' radius='5px' radius_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_font_icon icon='ue84b' font='entypo-fontello' style='' caption='' link='' linktarget='' size='40px' position='center' color='#acacac' av_uid=''][/av_font_icon]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#bf1a2d' av_uid='']
<h4 style="text-align: center;">Datasheet</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_button label='Download' link='manually,/productdocs/automate-zOS-STIGs-datasheet.pdf' link_target='_blank' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue887' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[av_hr class='invisible' height='40' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_font_icon icon='ue8bb' font='entypo-fontello' style='' caption='' link='' linktarget='' size='40px' position='center' color='#acacac' av_uid='' custom_class='' admin_preview_bg=''][/av_font_icon]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 style="text-align: center;">Resources</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_button label='View' link='page,9435' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_third][/av_tab_sub_section][av_tab_sub_section tab_title='1 Minute Overview' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,20px' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">IronSphere: z/OS STIG Compliance Automation and Mainframe Security</h3>
<h4 class="nocaps" style="text-align: center;"><span style="color: #525252;">1 Minute Overview</span></h4>
[/av_textblock]

[/av_one_full][av_one_third first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='no_margin' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><span style="color: #525252;">Key Benefits:</span></h3>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' custom_content_size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='nocaps' admin_preview_bg='']
[av_iconlist_item title='Even Stronger Mainframe Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Automate z/OS STIG Compliance Work' link='' linktarget='' linkelement='' icon='ue864' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title=' More Manageable Compliance Mandates' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Find & Display Security Vulnerabilities' link='' linktarget='' linkelement='' icon='ue8de' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Help for Auditors; Painless Future Audits' link='' linktarget='' linkelement='' icon='ue803' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><span style="color: #525252;">IronSphere Automatically and Continuously:</span></h3>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='' custom_content_size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='nocaps' admin_preview_bg='']
[av_iconlist_item title='Runs Security Diagnostic Checks on Mainframe' link='' linktarget='' linkelement='' icon='ue856' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Complies with ISCM, RMF, DISA STIGs for z/OS' link='' linktarget='' linkelement='' icon='ue803' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Provides Simple Steps to Remediate Issues' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Updates Your Security Risks & Fix Status on GUI' link='' linktarget='' linkelement='' icon='ue86c' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Updates Audit Log with Scan Results' link='' linktarget='' linkelement='' icon='ue851' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Differentiators vs. Competing Solutions:</h3>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' animation='' custom_title_size='' custom_content_size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_bg='#bf1a2d' custom_font='' custom_border='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='nocaps' admin_preview_bg='']
[av_iconlist_item title='Run Scans on Regular Schedule' link='' linktarget='' linkelement='' icon='ue891' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='No Work on Your End to Run Scans' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='Receive Real-Time Remediation Guidance' link='' linktarget='' linkelement='' icon='ue812' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[av_iconlist_item title='GUI Display Provides Added Visibility' link='' linktarget='' linkelement='' icon='ue826' font='entypo-fontello' av_uid=''][/av_iconlist_item]
[/av_iconlist]

[/av_one_third][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='#e8e8e8' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[/av_tab_sub_section][av_tab_sub_section tab_title='Webinar' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the IronSphere Webinar page, please <a href="/security-software/automatic-mainframe-stig-monitoring/webinar/">click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='ironsphere']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='10px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the IronSphere Datasheet (opens in a new tab usually), <a href="/productdocs/automate-zOS-STIGs-datasheet.pdf" target="_blank" rel="noopener">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_portfolio categories='54' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' period_filter_unit_1='1' period_filter_unit_2='year' sort='yes' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section]
[/av_tab_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='hidecode' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' av_uid='' custom_class='hide']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="3"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/security-software/automatic-mainframe-stig-monitoring/webinar/#short-videos',
			  '_self'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' av_uid='' custom_class='hide']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="4"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/security-software/automatic-mainframe-stig-monitoring/webinar/',
			  '_self'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' av_uid='' custom_class='hide']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="5"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/productdocs/automate-zOS-STIGs-datasheet.pdf',
			  '_blank'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]
[/av_section]

[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;">Automatic, Security Standards-based Monitoring with IronSphere for z/OS</h2>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Thank you to those who joined us for this webinar.  During the webinar, the creator of IronSphere for z/OS provided a product overview along with a demonstration.</p>
[/av_textblock]

[av_button label='Webinar Details' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,8303' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/binary-red-banner.jpg' attachment='15793' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:17:"2022-new-features";s:6781:"[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='no-padding' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Newly Released and Upcoming Features</h3>
[/av_textblock]

[av_one_third first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='20px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='#ffffff' custom_bg='#525252' custom_border='#525252' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Application Tier Menu' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0']
IPv6 compatible plus VWA will run dual stack IPv4 and IPv6.
[/av_iconlist_item]


[/av_iconlist]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_bg='#525252' custom_font='#ffffff' custom_border='#525252' animation='' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='5250 Emulation' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0']
5250 emulation is now available through VWA.  Emulate your IBM iSeries AS/400 screens on the same emulator you use for your 3270 screens.
[/av_iconlist_item]
[/av_iconlist]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' custom_title='' custom_content='' color='custom' custom_font='#ffffff' custom_bg='#525252' custom_border='#525252' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Screen Lockout Functionality' icon='ue82b' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0']
Set global permissions based on desired period of inactivity.  This will lock screens and signout inactive users.
[/av_iconlist_item]
[/av_iconlist]

[/av_one_third][av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">For additional information, please read the latest <a href="https://sdsusastg.wpenginepowered.com/blog/news/quarterly-sds-virtel-newsletter/">Virtel Newsletter</a>.</p>
[/av_textblock]
[/av_section]";s:18:"2022-post-template";s:11657:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h1 class="secondary">Three Use-cases of ConicIT in action</h1>
[/av_textblock]

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">May 19, 2021</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']
[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 class="nocaps">First Fault Problem Resolution</h4>
As <a href="https://sdsusastg.wpenginepowered.com/mainframe-performance-optimization/conicit/">ConicIT</a> learns the system over time, it creates models of how system parameters should behave and how they may affect each other. In this example, ConicIT used its model of past CPU behavior to discover a non-standard behavior pattern of CPU unrest. Since the prediction model understood that such behavior may be indicative of future performance problems, it used that anomaly as the basis to request additional monitoring information (e.g., MVS) to analyze external resources (e.g., TSO) that could have also been accessing the CPU and causing the anomalous behavior, especially any dispatching waits. ConicIT also started requesting additional monitoring information from CICS to analyze whether the anomaly could be explained as a temporal phenomenon (e.g., day of the week) or as a result of CICS transaction dispatching waits or an internal CICS QRTCB.

As a result of its analysis of all of this data, the ConicIT analysis rules engine would decide whether to issue an alert. The collected data and the reasoning that triggered the data collection are stored by ConicIT for later analysis. The goal is that once an alert was issued, system programmers will have all the relevant information at their fingertips along with a basic causal analysis – all without putting noticeable load on the system being monitored. <b>It will be up to system programmers to solve the problem, but the diagnosis becomes an order of magnitude easier.</b>
<h4 class="nocaps">Batch Window Overrun</h4>
A current ConicIT customer had a problem occur over the weekend in handling transactions coming from Automated Teller Machines (ATMs). The following Monday, they were greeted by alerts regarding performance slowdowns over the weekend. None of the problems were severe enough to cause a panic over the weekend, but needed to be resolved to ensure that they weren’t indicative of a deeper issue.

The standard logs and monitors showed nothing unusual about the ATM transactions that occurred during the slowdown. However, ConicIT’s prediction engine had noticed a database resource contention issue (through anomalies in the DB2 resource usage information) and used that information to predict possible CICS transaction response time problems.

That prediction caused ConicIT to start collecting system information regarding the state of the database involved and the transactions that took place during the slowdown. <b>From that information, it was immediately clear to the system programmers that there was a standard overnight batch process that had overrun its batch window during which it had locked the database.</b> This occurred since the batch program needed to process an unusual amount of information received on the Friday before the weekend.
<h4 class="nocaps">Resource Contention</h4>
A large organization was experiencing intermittent performance slowdowns that affected various mainframe transactions, and there seemed to be no pattern to the slowdowns. Not surprisingly, by the time a slowdown was noticed, the relevant system information was no longer available via the monitor and not available in any log, making problem determination extremely difficult. This led them to pilot ConicIT to see if it could assist in diagnosing the problem.

ConicIT was installed to learn the standard behavior of the system. As part of that learning process, ConicIT’s prediction models learned the system’s standard behavior relating database resource availability and CPU thread activity to CICS transaction response time. As a result of the learning, when ConicIT sensed that DB2 resource wait time was starting to rise above the norm, it understood that this might be a predictor of a brewing transaction response time problem. This caused ConicIT’s prediction engine to proactively collect monitor information related to transaction response time, CPU thread information and DB2 resource usage - before the slowdown actually occurred.

<b>The next time the problem occurred, ConicIT predicted the problem and collected the relevant information before the actual slowdown was noticed.</b> Using this information, the system programmers understood exactly the state of the system during, and immediately before, the slowdown. The results of the analysis showed that there was a specific set of transactions that were heavy users of database resources, and when they occurred together could cause a general response time slowdown for the whole system.
[/av_textblock]
[/av_one_full]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#525252' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#525252' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.  ConicIT trials typically run for 60-90 days as the first 30 days are needed for the software to learn your system.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-1468' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:27:"2023-vwa-latest-videos-page";s:13340:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='' admin_preview_bg='']
<h1 class="secondary">Virtel<sup>®</sup> Web Access | VWA | Videos</h1>
[/av_textblock]

[av_textblock size='20' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="description">This is a collection of our latest Virtel Web Access videos</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='' custom_margin='0px' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' video_mobile_disabled='' overlay_enable='' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='scroll' bottom_border_style='scroll' scroll_down='' custom_arrow_bg='' av-desktop-hide='' av-medium-hide='' av-small-hide='' av-mini-hide='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_full first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<div style='padding:56.25% 0 0 0;position:relative;'><iframe src='https://vimeo.com/showcase/4505881/embed' allowfullscreen frameborder='0' style='position:absolute;top:0;left:0;width:100%;height:100%;'></iframe></div>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='80%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<div style="padding: 56.25% 0 0 0; position: relative;"><iframe style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;" src="https://vimeo.com/showcase/4422954/embed" frameborder="0" allowfullscreen="allowfullscreen"></iframe></div>
[/av_textblock]

[/av_one_full]
[/av_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-2543' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:26:"2025-home-first-row-6-card";s:35744:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='av-break-at-tablet' av_uid='' custom_class='']
[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='sds-card' template_class='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#bf1a2d' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="categoryTitles"><a href="https://www.sdsusa.com/mainframe-security-compliance/"><span class="lower">z</span>/OS Security & Compliance</a></h3>
[/av_textblock]

[av_three_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-security-compliance.png' attachment='16085' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='no-styling' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='left' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='page,95' link_dynamic='' target='' animation='fade-in' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='sds-card-icon' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='' padding='' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='80,0,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='sds-card-icon' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_font_icon icon='ue88d' font='entypo-fontello' style='' caption='' size='40px' position='right' color='#b02b2c' link='manually,https://sdsusastg.wpenginepowered.com/mainframe-network-management/' link_dynamic='' linktarget='' title_attr='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' animation='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_font_icon]

[/av_two_fifth][av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='sds-card-text' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<ul>
 	<li><a href="https://www.sdsusa.com/security-software/mainframe-siem/">VitalSigns SIEM Agent™ for z/OS</a> — Integrate mainframe security events into any enterprise SIEM</li>
 	<li><a href="https://www.sdsusa.com/security-software/vst/">VitalSigns for Secure Transfer™</a> — Automatic Secure Outbound Mainframe FTP Sessions</li>
 	<li><a href="https://www.sdsusa.com/security-software/vftp-ssh/">VFTP-SSH Collaboration</a> — Complete FTP security for z/OS; no JCL changes needed</li>
 	<li><a href="https://www.sdsusa.com/security-software/e-business-server/">SDS E-Business Server® for z/OS</a> — Rock-solid PGP encryption for data at rest</li>
 	<li><a href="https://www.sdsusa.com/security-software/automatic-mainframe-stig-monitoring/">SDS IronSphere for z/OS</a> — Automated DISA STIG compliance monitoring for z/OS</li>
</ul>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='sds-card' template_class='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#bf1a2d' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: left;"><span style="font-size: 18px;"><a href="/mainframe-network-management/">Mainframe Network Management</a></span></h3>
[/av_textblock]

[av_three_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-network.png' attachment='372' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='no-styling' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='left' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='page,95' link_dynamic='' target='' animation='fade-in' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='sds-card-icon' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='' padding='' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='80,0,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='sds-card-icon' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_font_icon icon='ue88d' font='entypo-fontello' style='' caption='' size='40px' position='right' color='#b02b2c' link='manually,https://sdsusastg.wpenginepowered.com/mainframe-network-management/' link_dynamic='' linktarget='' title_attr='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' animation='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_font_icon]

[/av_two_fifth][av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='sds-card-text' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<ul>
 	<li><a href="https://www.sdsusa.com/mainframe-network-management/vftp/">VitalSigns for FTP™</a> — Snap-in security for file transfers to & from z/OS</li>
 	<li><a href="https://www.sdsusa.com/mainframe-network-management/vip/">VitalSigns for IP™</a> — Complete IP monitoring on z/OS</li>
 	<li><a href="https://www.sdsusa.com/mainframe-network-management/vnac/">VitalSigns for NAC™</a> — Replace legacy mainframe network monitoring</li>
</ul>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='sds-card' template_class='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#bf1a2d' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="categoryTitles"><a href="https://www.sdsusa.com/mainframe-performance-optimization/">Mainframe Performance & Optimization</a></h3>
[/av_textblock]

[av_three_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-performance.png' attachment='373' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='no-styling' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='left' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='page,95' link_dynamic='' target='' animation='fade-in' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='sds-card-icon' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='' padding='' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='80,0,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='sds-card-icon' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_font_icon icon='ue88d' font='entypo-fontello' style='' caption='' size='40px' position='right' color='#b02b2c' link='manually,https://sdsusastg.wpenginepowered.com/mainframe-network-management/' link_dynamic='' linktarget='' title_attr='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' animation='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_font_icon]

[/av_two_fifth][av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='sds-card-text' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<ul>
 	<li><a href="https://www.sdsusa.com/mainframe-performance-optimization/conicit/">ConicIT®</a> — Predictive operations management and analysis for z/OS</li>
 	<li><a href="https://www.sdsusa.com/mainframe-performance-optimization/multiterm/">Multiterm™ for z/OS, z/VM, & z/VSE</a> — Premier session manager for z Series mainframes</li>
</ul>
[/av_textblock]

[/av_cell_one_third]
[/av_layout_row]";s:27:"2025-home-second-row-6-card";s:35659:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='av-break-at-tablet' av_uid='' custom_class='']
[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='sds-card' template_class='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#bf1a2d' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="categoryTitles"><a href="https://www.sdsusa.com/application-access-modernization/">Application Access & Modernization</a></h3>
[/av_textblock]

[av_three_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-application-access.png' attachment='375' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='no-styling' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='left' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='page,95' link_dynamic='' target='' animation='fade-in' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='sds-card-icon' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='' padding='' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='80,0,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='sds-card-icon' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_font_icon icon='ue88d' font='entypo-fontello' style='' caption='' size='40px' position='right' color='#b02b2c' link='manually,https://sdsusastg.wpenginepowered.com/mainframe-network-management/' link_dynamic='' linktarget='' title_attr='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' animation='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_font_icon]

[/av_two_fifth][av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='sds-card-text' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<ul>
 	<li><a href="https://www.sdsusa.com/application-access-modernization/virtel-web-access/">Virtel® Web Access</a> — Ultra-thin and secure 3270 TE on any device</li>
 	<li><a href="https://www.sdsusa.com/application-access-modernization/virtel-web-modernization/">Virtel® Web Modernization</a> — Serve host transactions as user-friendly web pages (GUIs)</li>
 	<li><a href="https://www.sdsusa.com/application-access-modernization/virtel-web-integration/">Virtel® Web Integration</a> — Create interactive bidirectional connections; integrate host & web</li>
 	<li><a href="https://www.sdsusa.com/application-access-modernization/virtel-screen-redesigner/">Virtel® Screen Redesigner</a> — Create modern and user-friendly web UIs from your existing legacy 3270 screens</li>
</ul>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='sds-card' template_class='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#bf1a2d' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="categoryTitles"><a href="https://www.sdsusa.com/cics-management/">CICS Management</a></h3>
[/av_textblock]

[av_three_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-cics.png' attachment='374' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='no-styling' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='left' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='page,95' link_dynamic='' target='' animation='fade-in' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='sds-card-icon' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='' padding='' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='80,0,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='sds-card-icon' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_font_icon icon='ue88d' font='entypo-fontello' style='' caption='' size='40px' position='right' color='#b02b2c' link='manually,https://sdsusastg.wpenginepowered.com/mainframe-network-management/' link_dynamic='' linktarget='' title_attr='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' animation='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_font_icon]

[/av_two_fifth][av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='sds-card-text' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<ul>
 	<li><a href="https://www.sdsusa.com/cics-management/cafc/">CAFC™</a> — CICS Application File Control system software</li>
 	<li><a href="https://www.sdsusa.com/cics-management/ipcp-plus/">IPCP™ Plus for z/OS & z/VSE</a> — Premier file control utility for z/OS & z/VSE</li>
</ul>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='sds-card' template_class='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#bf1a2d' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="categoryTitles"><a href="https://www.sdsusa.com/encryption-ssh-solutions/">Encryption & SSH Solutions</a></h3>
[/av_textblock]

[av_three_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-security.png' attachment='371' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='no-styling' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='left' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='page,95' link_dynamic='' target='' animation='fade-in' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='sds-card-icon' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_two_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='' padding='' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='80,0,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='sds-card-icon' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_font_icon icon='ue88d' font='entypo-fontello' style='' caption='' size='40px' position='right' color='#b02b2c' link='manually,https://sdsusastg.wpenginepowered.com/mainframe-network-management/' link_dynamic='' linktarget='' title_attr='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' animation='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_font_icon]

[/av_two_fifth][av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='sds-card-text' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<ul>
 	<li><a href="https://www.sdsusa.com/security-software/privx-key-manager/">PrivX™ Key Manager</a> — Centralize, simplify, and automate SSH key management</li>
 	<li><a href="https://www.sdsusa.com/security-software/privx/">PrivX PAM</a> — Zero-trust privileged access management (PAM)</li>
 	<li><a href="https://www.sdsusa.com/security-software/e-business-server/">SDS E-Business Server®</a> — Enterprise-wide data encryption, authentication, security</li>
 	<li><a href="https://www.sdsusa.com/security-software/tectia-ssh/">Tectia® SSH</a> — Server and client that secures and encrypts file transfers and more</li>
</ul>
[/av_textblock]

[/av_cell_one_third]
[/av_layout_row]";s:28:"2025-three-card-home-section";s:40987:"[av_layout_row min_height_percent='50' min_height_pc='25' min_height='80vh' border='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' color='main_color' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' mobile='av-flex-cells' mobile_breaking='av-break-at-tablet' mobile_column_order='' av-medium-hide='aviaTBav-medium-hide' av-small-hide='aviaTBav-small-hide' av-mini-hide='aviaTBav-mini-hide' id='' custom_class='home-3-card-section2025' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='360px' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#e5e4e4' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='resource-card' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='left' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="text-align: left;"><span style="font-size: 25px;">Webinar</span></h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#0a0a0a' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: left; margin-bottom: 40px;">Watch this 30-minute webinar focusing on the capabilities of Virtel Screen Recordings.</p>
[/av_textblock]

[av_button label='WATCH NOW' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' title_attr='' button_type='' link='manually,https://www.sdsusa.com/application-access-modernization/virtel-screen-redesigner/vsr-webinar/' link_dynamic='' link_target='' download_file='https://' attachment='' attachment_size='' downloaded_file_name='' size='medium' position='left' label_display='' size-text='17' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='color_options_advanced' color='white' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='dark' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='black' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='none' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_full][av_four_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='auto' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='180,-50,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='relative' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='home-text-column-align' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/Man-with-a-headset-on-talking-on-a-video-work-call-scaled.jpg' attachment='24945' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' link_dynamic='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='absolute' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_four_fifth][/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='360px' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#e5e4e4' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='resource-card' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#0a0a0a' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3><strong><span style="font-size: 25px;">Solutions</span></strong></h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#0a0a0a' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: left;">SDS offers a wide range of products focusing primarily on mainframe security and compliance and multi-platform encryption.</p>
[/av_textblock]

[av_button label='VIEW ALL SOLUTIONS' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' title_attr='' button_type='' link='page,16' link_dynamic='' link_target='' download_file='https://' attachment='' attachment_size='' downloaded_file_name='' size='medium' position='left' label_display='' size-text='17' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='color_options_advanced' color='white' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='dark' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='dark' btn_custom_bg_hover='#444444' btn_color_font='black' btn_custom_font='#ffffff' btn_color_font_hover='black' btn_custom_font_hover='#ffffff' border='none' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='none' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_full][av_four_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='auto' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='180,-50,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='home-text-column-align' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/Red-Gradient-background-with-cartoon-locks-throughout-scaled.jpg' attachment='24946' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' link_dynamic='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='absolute' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_four_fifth][/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='360px' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#e5e4e4' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='resource-card' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="text-align: left;"><span style="font-size: 25px;">SECURE z/OS FTP</span></h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#0a0a0a' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: left;">This popular solution cures any z/OS FTP compliance headaches you may have while providing multiple layers of security for file transfers.</p>
[/av_textblock]

[av_button label='FIND OUT MORE' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' title_attr='' button_type='' link='manually,https://www.sdsusa.com/security-software/vftp-ssh/' link_dynamic='' link_target='' download_file='https://' attachment='' attachment_size='' downloaded_file_name='' size='medium' position='left' label_display='' size-text='17' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='color_options_advanced' color='white' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='dark' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='dark' btn_custom_bg_hover='#444444' btn_color_font='black' btn_custom_font='#ffffff' btn_color_font_hover='black' btn_custom_font_hover='#ffffff' border='none' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='none' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_full][av_four_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='auto' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='180,-50,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='home-text-column-align' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/Labtop-with-a-cartoon-lock-over-top-of-it-scaled.jpg' attachment='24947' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' link_dynamic='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='absolute' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_four_fifth][/av_cell_one_third]
[/av_layout_row]";s:40:"2025home-first-functionality-code-6-card";s:854:"[av_codeblock wrapper_element='script' wrapper_element_attributes='' codeblock_type='' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']
document.addEventListener('DOMContentLoaded', function () {
  var cards = document.querySelectorAll('.sds-card');
  cards.forEach(function(card){
    var offTimer;

    function activate()   { clearTimeout(offTimer); card.classList.add('is-hovered'); }
    function deactivate() { offTimer = setTimeout(function(){ card.classList.remove('is-hovered'); }, 160); }

    card.addEventListener('mouseenter', activate);
    card.addEventListener('mouseleave', deactivate);

    // Keyboard accessibility mirrors behavior
    card.addEventListener('focusin', activate);
    card.addEventListener('focusout', function(){ card.classList.remove('is-hovered'); });
  });
});
[/av_codeblock]";s:18:"2303-columbus-post";s:43942:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h1 class="secondary">Highlights | SHARE Columbus 2022</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">August 30, 2022
Thank you for stopping by the SDS booth at the Tech Expo.</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-slide-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' av_element_hidden_in_editor='0' av_admin_tab_active='5' bg_color='#7f7f7f' color='#ffffff' id='' custom_class='' aria_label='' av_uid='']
[av_tab_sub_section tab_title='Info & News' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_two_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
It was great to see everyone back at SHARE in Columbus, Ohio!  We look forward to engaging with all of you at SHARE and we were glad to be back.  We had some excellent conversations with current users and others in the mainframe industry. Thank you to everyone who stopped by the SDS booth!
<h3 class="nocaps">News and Updates</h3>
We are continuing to add new features and enhancements to the software solutions we offer. The bulk of our ongoing product development projects at SDS center around our security and compliance solutions.

The new release of VitalSigns SIEM Agent<sup>™</sup> for z/OS 4.2.1 contains significant enhancements. We've also been enhancing the rest of our <a href="https://sdsusastg.wpenginepowered.com/mainframe-network-management/">VitalSigns suite of products</a> to ensure they continue to be the best-in-class z/OS monitors our users expect.

For more information regarding our mainframe solutions, see our categories listed below.
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/SHARE-Columbus-2022-scaled.jpg' attachment='22634' attachment_size='full' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_one_third][/av_tab_sub_section][av_tab_sub_section tab_title='Automate z/OS STIGs' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="nocaps">IronSphere for z/OS</h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock size='15' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li>Automate Tedious z/OS STIG Compliance Work</li>
 	<li>More Manageable Compliance Mandates</li>
 	<li>Find & Display Security Vulnerabilities</li>
 	<li>Remediation Steps Delivered in GUI</li>
 	<li>Help for Auditors; Painless Future Audits</li>
 	<li>Even Stronger Mainframe Security</li>
</ul>
[/av_textblock]

[av_button label='IronSphere page' link='page,7173' link_target='' size='large' position='left' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/332435591' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Secure 3270 TE+' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='tab24' av_uid='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="nocaps">Virtel<sup>®</sup> Web Access</h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock size='15' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<ul>
 	<li>Ultra-Thin Client Architecture promotes Security, Mobility, and Agility</li>
 	<li>Replace your 3270 Terminal Emulator and Save up to 80%</li>
 	<li>Serve 3270 Screens on Browser over Encrypted HTTPS Connections</li>
 	<li>End Dependence on Unsafe Applets and Plugins: Java plugin is NOT used</li>
 	<li>Easy Deployment and Eliminate Need for Workstation-level Support and Updates</li>
</ul>
[/av_textblock]

[av_button label='VWA page' link='page,4289' link_target='' size='large' position='left' label_display='' title_attr='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_hr class='invisible' height='20' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="nocaps">Virtel<sup>®</sup> Web Suite</h2>
[/av_textblock]

[av_textblock size='15' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<ul>
 	<li>3 Solutions that can offer a <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/2019-webisode-series/">Security-conscious Digital Transformation</a></li>
 	<li>Modernize 3270 Screens</li>
 	<li>Full z/OS Web Integration; API-based Microservices</li>
</ul>
[/av_textblock]

[av_button label='VWS page' link='page,101' link_target='' size='large' position='left' label_display='' title_attr='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/363798609' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' av_uid='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Secure z/OS FTP' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="nocaps">The VFTP-SSH Collaboration</h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li>Automatic FTP to SFTP Conversion</li>
 	<li>No JCL Changes</li>
 	<li>Pass FTP-related Compliance Requirements</li>
 	<li>Visibility of all Transfers to/from Mainframe</li>
 	<li>Multi-layered Data Transfer Security</li>
 	<li>Integrate z/OS FTP Server with your SAF for Added Security</li>
</ul>
[/av_textblock]

[av_button label='VFTP-SSH page' link='page,1199' link_target='' size='large' position='left' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/312778955' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Save on z/OS Compiling' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps">Cloud Compiling for z/OS</h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<ul>
 	<li>Reduce z/OS compiler costs by 50% or more</li>
 	<li>Quick install software; takes less than an hour to install trial package</li>
 	<li>No risk to try software</li>
 	<li>No additional work for z/OS programmers</li>
 	<li>Easier and more affordable to scale in future</li>
 	<li>Secure process; no changes are required</li>
</ul>
[/av_textblock]

[av_button label='ConicIT page' link='page,1425' link_target='' size='large' position='left' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://youtu.be/VbxcAJiBkps' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='z/OS SIEM Agent' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='tab24' av_uid='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="nocaps">VitalSigns SIEM Agent<sup>™</sup> for z/OS</h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock size='15' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li>Real-Time Delivery of Important z/OS Event Records to SIEM</li>
 	<li>Automates z/OS Event Logging Process</li>
 	<li>Helps Achieve Security Compliance for z/OS</li>
 	<li>Alerts when Threat/Breach is Detected</li>
 	<li>Integrates well with any SIEM; Certified CEF and LEEF formats</li>
 	<li>Filters out Noise; Save Resources</li>
</ul>
[/av_textblock]

[av_button label='VSA page' link='page,1665' link_target='' size='large' position='left' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px,0px,0px,0px' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_video src='https://vimeo.com/300932649' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section]
[/av_tab_section]

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']
[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 style="text-align: center;">SDS Solutions</h3>
[/av_textblock]
[/av_one_full]

[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='av-break-at-tablet' av_uid='' custom_class='']
[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#f7f7f7' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-security-compliance.png' attachment='16085' attachment_size='full' align='center' styling='no-styling' hover='' link='page,15555' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='fade-in' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_textblock size='' font_color='custom' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/mainframe-security-compliance/"><span class="lower">z</span>/OS Security & Compliance</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="f7f7f7gray3">
<tbody>
<tr>
<td><a href="/security-software/mainframe-siem/">VitalSigns SIEM Agent<sup>™</sup> for z/OS</a></td>
<td>Integrate mainframe security events into any enterprise SIEM</td>
</tr>
<tr>
<td><a href="/security-software/vftp-ssh/">VFTP-SSH Collaboration</a></td>
<td>Complete FTP security for z/OS; no JCL changes needed</td>
</tr>
<tr>
<td><a href="/security-software/e-business-server/">SDS E-Business Server<sup>®</sup> for z/OS</a></td>
<td>Rock-solid PGP encryption for data at rest</td>
</tr>
<tr>
<td><a href="/security-software/automatic-mainframe-stig-monitoring/">SDS IronSphere for z/OS</a></td>
<td>Automated DISA STIG compliance monitoring for z/OS</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-network.png' attachment='372' attachment_size='full' align='center' styling='no-styling' hover='' link='page,95' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/mainframe-network-management/">Mainframe Network Management</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="e8e8e8gray3">
<tbody>
<tr>
<td><a href="/mainframe-network-management/vftp/">VitalSigns for FTP<sup>™</sup></a></td>
<td>Snap-in security for file transfers to & from z/OS</td>
</tr>
<tr>
<td><a href="/mainframe-network-management/vip/">VitalSigns for IP<sup>™</sup></a></td>
<td>Complete IP monitoring on z/OS</td>
</tr>
<tr>
<td><a href="/mainframe-network-management/vnac/">VitalSigns for NAC<sup>™</sup></a></td>
<td>Replace legacy mainframe network monitoring</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#cacaca' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-performance.png' attachment='373' attachment_size='full' align='center' styling='no-styling' hover='' link='page,97' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/mainframe-performance-optimization/">Mainframe Performance & Optimization</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<table class="cacacagray3">
<tbody>
<tr>
<td><a href="/mainframe-performance-optimization/conicit/">ConicIT<sup>®</sup></a></td>
<td>Predictive operations management and analysis for z/OS</td>
</tr>
<tr>
<td><a href="/mainframe-performance-optimization/cloud-compiling-zos/">Cloud Compiling for z/OS</a></td>
<td>Reduce compiling redundancies and save 50% guaranteed</td>
</tr>
<tr>
<td>
<a href="/mainframe-performance-optimization/multiterm/">Multiterm<sup>™</sup> for z/OS, z/VM, & z/VSE</a></td>
<td>Premier session manager for z Series mainframes</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third]
[/av_layout_row]

[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='av-break-at-tablet' av_uid='' custom_class='']
[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-application-access.png' attachment='375' attachment_size='full' align='center' styling='no-styling' hover='' link='page,101' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/application-access-modernization/">Application Access & Modernization</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="e8e8e8gray3">
<tbody>
<tr>
<td><a href="/application-access-modernization/virtel-web-access/">Virtel<sup>®</sup> Web Access</a></td>
<td>Ultra-thin and secure 3270 TE on any device</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-web-modernization/">Virtel<sup>®</sup> Web Modernization</a></td>
<td>Serve host transactions as user-friendly web pages (GUIs)</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-web-integration/">Virtel<sup>®</sup> Web Integration</a></td>
<td>Create interactive bidirectional connections; integrate host & web</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#cacaca' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-cics.png' attachment='374' attachment_size='full' align='center' styling='no-styling' hover='' link='page,99' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/cics-management/">CICS Management</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="cacacagray3">
<tbody>
<tr>
<td><a href="/cics-management/cafc/">CAFC<sup>™</sup></a></td>
<td>CICS Application File Control system software</td>
</tr>
<tr>
<td><a href="/cics-management/ipcp-plus/">IPCP<sup>™</sup> Plus for z/OS & z/VSE</a></td>
<td>Premier file control utility for z/OS & z/VSE</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#f7f7f7' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-security.png' attachment='371' attachment_size='full' align='center' styling='no-styling' hover='' link='page,16088' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='fade-in' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_textblock size='' font_color='custom' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/encryption-ssh-solutions/">Encryption & SSH Solutions</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<table class="f7f7f7gray3">
<tbody>
<tr>
<td><a href="/security-software/e-business-server/">SDS E-Business Server<sup>®</sup></a></td>
<td>Multi-platform PGP encryption for data at rest</td>
</tr>
<tr>
<td><a href="/security-software/tectia-ssh/">Tectia<sup>®</sup> SSH</a></td>
<td>Server and client that secures and encrypts file transfers and more</td>
</tr>
<tr>
<td><a href="/security-software/universal-ssh-key-manager/">Universal SSH Key Manager<sup>®</sup></a></td>
<td>Centralize, simplify, and automate SSH key management</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#bf1a2d' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="whitetrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-694' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:23:"021624-hidecode-element";s:1274:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='hidecode' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' alb_description='' id='' custom_class='hide' template_class='' av_uid='' sc_version='1.0']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="3"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/productdocs/automate-zOS-STIGs-datasheet.pdf',
			  '_blank'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]
[/av_section]";s:35:"022124-vsr-webinar-bb-red-text-left";s:6564:"[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='' av_uid='' custom_class='']

[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description" style="text-align: center;">Green Screen No More! Tracking a Customer’s Path to Modern Web UIs</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Join us as we look into a recent customer success story.  Register now for this 30-minute webinar on Wednesday, February 28 at 1:00PM CT.</p>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://my.demio.com/ref/4wSCblsczgtiEYE8?source=sdsusa' link_target='_blank' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/tablet-red-banner.jpg' attachment='15858' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][/av_layout_row]";s:20:"031523-iron-web-page";s:28760:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='#acacac' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' custom_class='' av_uid='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h1 class="secondary">IronSphere for z/OS | Webinar</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">Automatic STIG Compliance Monitoring for z/OS and iSeries with One Tool</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' custom_class='' av_uid=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-slide-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='4' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Watch Webinar' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Automatic STIG Compliance Monitoring for z/OS and iSeries with One Tool</h3>
<p style="text-align: center;">SDS IronSphere for z/OS webinar - March 15, 2023</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_video src='https://vimeo.com/808415103' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Handouts' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_masonry_gallery ids='22949,7423,15539' caption_elements='title excerpt' caption_styling='' caption_display='always' img_copyright='' size='flex' orientation='' image_size='no scaling' gap='large' columns='flexible' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='' custom_bg='' img_copyright_font='' av-desktop-font-img_copyright_font='' av-medium-font-img_copyright_font='' av-small-font-img_copyright_font='' av-mini-font-img_copyright_font='' img_copyright_color='' img_copyright_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='_blank' lightbox_text='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section][av_tab_sub_section tab_title='Webinar Details' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 class="nocaps">Automatic STIG Compliance Monitoring for z/OS and iSeries</h4>
This 30-minute webinar will cover:
<ul>
 	<li>Explore the changing threat landscape and the need for IronSphere on z/OS and iSeries.</li>
 	<li>Go over what IronSphere does and how it can help your organization.</li>
 	<li>Show IronSphere in action with a demo.</li>
</ul>
<strong>We hope you can join us for this webinar on Wednesday, March 15 at 1:00PM CT.</strong>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='_blank' size='large' position='left' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='90%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Featured Presenter:</h3>
<ul>
 	<li><b class="black">Itschak Mugzach</b>, founder and managing director of SecuriTeam software, creator of IronSphere for z/OS and iSeries.</li>
</ul>
Itschak will explore the changing threat landscape and how IronSphere will help your organization's z/OS and iSeries security. There will also be a brief product demo.
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h5 class="nocaps" style="text-align: center;">IronSphere for z/OS and iSeries</h5>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_font='' custom_bg='#bf1a2d' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='nocaps' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Stronger, Standards-based Mainframe Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Automate Tedious STIG Compliance Work' icon='ue864' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title=' More Manageable Compliance Mandates' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Find & Display Security Vulnerabilities' link='' linktarget='' linkelement='' icon='ue8de' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Simple Risk Remediation Steps Provided' link='' linktarget='' linkelement='' icon='ue84b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Help for Auditors; Painless Future Audits' link='' linktarget='' linkelement='' icon='ue803' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Abstract</h3>
Learn all about IronSphere for z/OS and iSeries in this presentation, featuring Itschak Mugzach, founder of IronSphere.

Staying up to date on DISA STIGs and NIST ISCM requirements and then checking to verify your mainframe is passing these security standards is continuous and a lot of ongoing work and hassle.  

<strong>Why not automate these cumbersome tasks instead?</strong>

This STIG-reporting tool will find security issues now. Don’t wait for audit time; follow risk-based security and compliance protocols for the mainframe.  Baselines are created in short cycles, diagnostic routines are triggered, and up-to-date reports along with calculated risk scores for your monitored systems are displayed.
<h4 class="nocaps">During this presentation, we will:</h4>
<ul>
 	<li>Explore the changing threat landscape and the need for IronSphere on z/OS and iSeries.</li>
 	<li>Go over what IronSphere does and how it can help your organization.</li>
 	<li>Show IronSphere in action with a demo.</li>
</ul>
<strong>We hope you can join us for this webinar on Wednesday, March 15 at 1:00PM CT.</strong>
<h4 class="nocaps">More about IronSphere:</h4>
IronSphere continuously monitors z/OS and iSeries systems, comparing your system to DISA STIG and NIST ISCM standards.  When vulnerabilities are identified, complete remediation steps are delivered.

If your organization is following security standards on the mainframe, compare the simplicity that IronSphere provides to the process you're undertaking today.

IronSphere for z/OS and iSeries - product details:
<ul>
 	<li>Automated, real-time STIG compliance monitoring and remediation.</li>
 	<li>Continuous cybersecurity monitoring and auditing.</li>
 	<li>Customizable:
<ul>
 	<li>remove checks with documentation,</li>
 	<li>create new checks,</li>
 	<li>request additional checks be created by IronSphere team.</li>
</ul>
</li>
 	<li>Results are provided in a GUI, perfect for security folks and other non-mainframers.</li>
</ul>

<hr />

This webinar is sponsored by Software Diversified Services (SDS).
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_portfolio categories='54' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' period_filter_unit_1='1' period_filter_unit_2='year' sort='yes' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section]
[/av_tab_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:24:"031523-iron-webinar-page";s:47834:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='#acacac' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' custom_class='' av_uid='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h1 class="secondary">IronSphere for z/OS | Webinar</h1>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">Upcoming: March 15, 2023 at 1:00PM CT: Automatic STIG Compliance Monitoring for z/OS and iSeries with One Tool</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' custom_class='' av_uid=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-slide-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' id='' av_element_hidden_in_editor='0' av_admin_tab_active='1' bg_color='' color='' av_uid='' custom_class='']
[av_tab_sub_section tab_title='Webinar Details' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' tab_deeplink='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_half first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='10px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' custom_class='' av_uid='']
<h3>Webinar</h3>
[/av_textblock]

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 class="nocaps">Automatic STIG Compliance Monitoring for z/OS and iSeries</h4>
This 30-minute webinar will cover:
<ul>
 	<li>Explore the changing threat landscape and the need for IronSphere on z/OS and iSeries.</li>
 	<li>Go over what IronSphere does and how it can help your organization.</li>
 	<li>Show IronSphere in action with a demo.</li>
</ul>
<strong>We hope you can join us for this webinar on Wednesday, March 15 at 1:00PM CT.</strong>
[/av_textblock]

[av_button label='Register Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,https://my.demio.com/ref/VVCmGuSdvKXcWQXw&source=sdsusa' link_target='_blank' size='large' position='left' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='90%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Featured Presenter:</h3>
<ul>
 	<li><b class="black">Itschak Mugzach</b>, founder and managing director of SecuriTeam software, creator of IronSphere for z/OS and iSeries.</li>
</ul>
Itschak will explore the changing threat landscape and how IronSphere will help your organization's z/OS and iSeries security. There will also be a brief product demo.
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='20px' padding_sync='true' border='1' border_color='#acacac' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Key Benefits</h3>
<h5 class="nocaps" style="text-align: center;">IronSphere for z/OS and iSeries</h5>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='18' av-desktop-font-size-title='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' custom_title='#525252' custom_content='' color='custom' custom_font='' custom_bg='#bf1a2d' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='nocaps' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Stronger, Standards-based Mainframe Security' link='' linktarget='' linkelement='' icon='ue824' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Automate Tedious STIG Compliance Work' icon='ue864' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title=' More Manageable Compliance Mandates' link='' linktarget='' linkelement='' icon='ue82b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Find & Display Security Vulnerabilities' link='' linktarget='' linkelement='' icon='ue8de' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Simple Risk Remediation Steps Provided' link='' linktarget='' linkelement='' icon='ue84b' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Help for Auditors; Painless Future Audits' link='' linktarget='' linkelement='' icon='ue803' font='entypo-fontello' av_uid='' heading_tag='' heading_class='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_full first min_height='' vertical_alignment='av-align-top' space='' margin='0px,10px' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Abstract</h3>
Learn all about IronSphere for z/OS and iSeries in this presentation, featuring Itschak Mugzach, founder of IronSphere.

Staying up to date on DISA STIGs and NIST ISCM requirements and then checking to verify your mainframe is passing these security standards is continuous and a lot of ongoing work and hassle.  

<strong>Why not automate these cumbersome tasks instead?</strong>

This STIG-reporting tool will find security issues now. Don’t wait for audit time; follow risk-based security and compliance protocols for the mainframe.  Baselines are created in short cycles, diagnostic routines are triggered, and up-to-date reports along with calculated risk scores for your monitored systems are displayed.
<h4 class="nocaps">During this presentation, we will:</h4>
<ul>
 	<li>Explore the changing threat landscape and the need for IronSphere on z/OS and iSeries.</li>
 	<li>Go over what IronSphere does and how it can help your organization.</li>
 	<li>Show IronSphere in action with a demo.</li>
</ul>
<strong>We hope you can join us for this webinar on Wednesday, March 15 at 1:00PM CT.</strong>
<h4 class="nocaps">More about IronSphere:</h4>
IronSphere continuously monitors z/OS and iSeries systems, comparing your system to DISA STIG and NIST ISCM standards.  When vulnerabilities are identified, complete remediation steps are delivered.

If your organization is following security standards on the mainframe, compare the simplicity that IronSphere provides to the process you're undertaking today.

IronSphere for z/OS and iSeries - product details:
<ul>
 	<li>Automated, real-time STIG compliance monitoring and remediation.</li>
 	<li>Continuous cybersecurity monitoring and auditing.</li>
 	<li>Customizable:
<ul>
 	<li>remove checks with documentation,</li>
 	<li>create new checks,</li>
 	<li>request additional checks be created by IronSphere team.</li>
</ul>
</li>
 	<li>Results are provided in a GUI, perfect for security folks and other non-mainframers.</li>
</ul>

<hr />

This webinar is sponsored by Software Diversified Services (SDS).
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='Past Webinars' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/automatic-mainframe-stig-monitoring/webinar/security-standards-based-monitoring-with-ironsphere-for-zos">Automatic, Security Standards-based Monitoring with IronSphere for z/OS</a></h3>
<p style="text-align: center;">The latest IronSphere for z/OS webinar from April 21, 2022 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/automatic-mainframe-stig-monitoring/webinar/security-standards-based-monitoring-with-ironsphere-for-zos">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/ironsphere-webinar-page-0422.png' attachment='22470' attachment_size='full' copyright='' caption='' image_size='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,22463' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_one_full first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='aviaTBcustom_margin' margin='10px,0px' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px' padding_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='100%' custom_margin_top='30px' custom_margin_bottom='30px' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[av_textblock textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;"><a href="https://sdsusastg.wpenginepowered.com/security-software/automatic-mainframe-stig-monitoring/webinar/disa-stigs-for-zos-and-automating-process/">Exploring DISA STIGs for z/OS and Automating the Process</a></h3>
<p style="text-align: center;">This IronSphere for z/OS webinar from February 5, 2020 is available <a href="https://sdsusastg.wpenginepowered.com/security-software/automatic-mainframe-stig-monitoring/webinar/disa-stigs-for-zos-and-automating-process/">here</a>.</p>
[/av_textblock]

[av_hr class='custom' icon_select='no' icon='ue808' font='entypo-fontello' position='center' shadow='no-shadow' height='50' custom_border='av-border-thin' custom_width='60%' custom_margin_top='0' custom_margin_bottom='0' custom_border_color='#acacac' custom_icon_color='' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_full][av_one_fifth first min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' border='' border_color='' radius='0px' radius_sync='true' padding='0px,0px,0px,0px' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/ironsphere-webinar-page-0220.png' attachment='22411' attachment_size='full' copyright='' caption='' image_size='' styling='no-styling' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='page,22291' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' custom_margin='' margin='0px' mobile_breaking='' border='' border_color='' radius='0px' padding='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' aria_label='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Short Videos' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' vertical_align='middle' color='' inactive_color='' color_hover='' inactive_color_hover='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">z/OS STIG Compliance</h3>
<h4 class="nocaps" style="text-align: center;">How to Think about STIGs and Automating the Tedious Process</h4>
<p style="text-align: center;">SDS IronSphere for z/OS webinar - April 23, 2019</p>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0' custom_margin_bottom='0' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">IronSphere Demo</h4>
<p style="text-align: center;">(4 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/332435591' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Question & Answer Session</h4>
<p style="text-align: center;">(4 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/332443855' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_full first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">Automating z/OS STIG Compliance with Real-time, Continuous Security Monitoring and Simplified Audits</h3>
<h4 class="nocaps" style="text-align: center;">SDS IronSphere for z/OS webinar - October 17, 2018</h4>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='60%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='0px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_full][av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Features and Highlights of this Mainframe STIG Automation Tool</h4>
<p style="text-align: center;">(11 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/297751954' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">IronSphere for z/OS can Stop Hackers by Identifying Mainframe Security Vulnerabilities Continuously</h4>
<p style="text-align: center;">(8 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/297751984' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Stu Henderson's Introduction and History of Auditors and Mainframe Security Standards</h4>
<p style="text-align: center;">(10 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/297752034' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Stu Henderson Explains what Auditors Know about Security Standards</h4>
<p style="text-align: center;">(6 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/297752014' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">Stu Henderson’s Summary stresses the Need to Automate the Validation of your z/OS Security Standards</h4>
<p style="text-align: center;">(2 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/297752054' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h4 class="nocaps" style="text-align: center;">IronSphere Q&A Session with two Mainframe Security Experts</h4>
<p style="text-align: center;">(7 minutes)</p>
[/av_textblock]

[av_video src='https://vimeo.com/297751882' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='100%' custom_border_color='#acacac' custom_margin_top='0px' custom_margin_bottom='30px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[/av_tab_sub_section][av_tab_sub_section tab_title='Datasheet' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_one_full first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">If your browser failed to open the IronSphere Datasheet (opens in a new tab usually), <a href="/productdocs/automate-zOS-STIGs-datasheet.pdf" target="_blank" rel="noopener">please click here</a>.</p>
[/av_textblock]

[/av_one_full][/av_tab_sub_section][av_tab_sub_section tab_title='All Resources' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' av_uid='' custom_class='']

[av_portfolio categories='54' date_filter='' date_filter_start='' date_filter_end='' date_filter_format='yy/mm/dd' period_filter_unit_1='1' period_filter_unit_2='year' sort='yes' query_orderby='name' query_order='ASC' contents='excerpt' preview_mode='auto' image_size='no scaling' columns='4' av-medium-columns='' av-small-columns='' av-mini-columns='' one_column_template='special' items='16' paginate='yes' linking='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_tab_sub_section]
[/av_tab_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='hidecode' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' alb_description='' id='' custom_class='hide' template_class='' av_uid='' sc_version='1.0']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="4"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/productdocs/automate-zOS-STIGs-datasheet.pdf',
			  '_blank'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]
[/av_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#525252' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/security-gray-right.jpg' attachment='15817' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-7290' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:15:"041025-VST-page";s:49886:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h1 class="secondary">VitalSigns for Secure Transfer™ | VST</h1>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='20' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="description">VST is a SOCKS proxy server that automatically secures outbound FTP sessions leveraging z/OS OpenSSH. No batch JCL changes are required.</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='' av_element_hidden_in_editor='0']
[av_one_half first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Secure Outbound File Transfers from Mainframe</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
VST secures outbound (client) mainframe FTP sessions using a SOCKS proxy to convert FTP to SFTP automatically. Supports both password and public key authentication. Additionally, there's no need to make any batch JCL changes.

This solution will allow your organization to follow mandated FTP-related compliance requirements without making massive changes to longstanding business logic.

VST provides a feature-rich user experience by enhancing the base OpenSSH technology.

<strong>Like all of our VitalSigns products, VST boasts a simple install and configuration process.  Plus, you'll benefit from our award-winning 24/7/365 technical support, where all expert technicians are located in the US.</strong>
[/av_textblock]

[av_button label='Request Demo/Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='left' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='theme-color' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-23747' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='0px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="nocaps" style="text-align: center;">VST and VFTP Integration</h3>
[/av_textblock]

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/VST-diagram.png' attachment='23740' attachment_size='full' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
VST is run in conjunction with <a href="https://sdsusastg.wpenginepowered.com/mainframe-network-management/vftp/">VFTP</a>, using OpenSSH for complete authentication and encryption of outbound mainframe FTP.  VST receives information about the FTP session from VFTP.  The VST server uses OpenSSH to establish secure connections and encrypt data transfers.  VST passes security information to VFTP agents to assist in writing SMF 119 records.
[/av_textblock]

[/av_one_half]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#525252' av_uid='']
<h4 style="text-align: center;">Compliance</h4>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">VST helps organizations meet the most stringent FTP-related standards from SOX, GDPR, GLBA, PCI DSS, HIPAA, and more.  VST's integration with VFTP provides the FTP security management and audit trail necessary for many security standards.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#525252' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Drop-in Security</h4>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">With minimal work, FTP is automatically converted to SFTP. No batch JCL changes are needed. VST also supports a tunneling option if that security method is required.</p>
[/av_textblock]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' padding='0px' border='' border_color='' radius='0px' background_color='' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-feature.png' attachment='380' attachment_size='full' align='center' styling='no-styling' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_hr class='invisible' height='5' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#525252' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Flexibility</h4>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">VST allows site administrators to better enforce security policies by controlling how sessions are managed. Administrators can direct how jobs are handled by users, with the flexibility to meet business operations and auditing requirements.</p>
[/av_textblock]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_uid='' av_element_hidden_in_editor='0']
[av_two_fifth first min_height='' vertical_alignment='av-align-middle' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='0px' radius_sync='true' min_col_height='' padding='0px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock size='' font_color='' color='' av_uid='']
<h3>Features</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<ul>
 	<li>SOCKS proxy automatically secures outbound sessions from mainframe</li>
 	<li>Existing batch jobs stay the same; No JCL changes!</li>
 	<li>Simple install and configuration</li>
 	<li>Integration with VitalSigns for FTP</li>
 	<li>Enhances base z/OS OpenSSH features</li>
 	<li>Built-in support for MVS datasets</li>
 	<li>Support for password and public-key authentication</li>
 	<li>SFTP transfers shown as one combined audit record</li>
 	<li>P<span class="ui-provider a b c d e f g h i j k l m n o p q r s t u v w x y z ab ac ae af ag ah ai aj ak" dir="ltr">rovides scalability to match growing workloads</span></li>
 	<li>Implement changes dynamically without recycling the VST server</li>
 	<li>Transfers data efficiently - doesn't waste time and resources tearing down connections</li>
 	<li>24/7/365 access to award-winning SDS technical support - 100% US-based experts</li>
</ul>
[/av_textblock]

[/av_two_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='5px' radius_sync='true' min_col_height='' padding='0px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Learn More</h3>
[/av_textblock]

[av_masonry_gallery ids='24173,24240,24183' ids_dynamic='' caption_elements='title' caption_styling='' caption_display='always' img_copyright='' size='flex' orientation='' image_size='no scaling' gap='large' columns='2' av-desktop-columns='' av-medium-columns='' av-small-columns='' av-mini-columns='' items='24' paginate='none' color='custom' custom_bg='#e8e8e8' img_copyright_font='' av-desktop-font-img_copyright_font='' av-medium-font-img_copyright_font='' av-small-font-img_copyright_font='' av-mini-font-img_copyright_font='' img_copyright_color='' img_copyright_bg='' animation='active' animation_duration='' animation_custom_bg_color='' animation_custom_bg_color_multi_list='' animation_z_index_curtain='100' overlay_fx='active' container_links='' link_dest='' lightbox_text='' img_scrset='' lazy_loading='disabled' alb_description='' id='' custom_class='masonwborders' template_class='' av_uid='' sc_version='1.0']

[/av_three_fifth]
[/av_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='' av_element_hidden_in_editor='0']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='#525252' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/file-security-gray-right.jpg' attachment='15792' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background_color='#525252' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' mobile_display='' custom_class='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='']
<h4 style="text-align: center;">Product Webinar</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h2 class="nocaps" style="text-align: center;"><b>Peeling the Onion!</b></h2>
<h2 class="nocaps" style="text-align: center;">Exploring Mainframe File Transfer Methods & Best Options for Security</h2>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: center;">Watch as we peel back the layers of the SFTP onion.</p>
[/av_textblock]

[av_button label='Watch Now' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='page,23431' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_cell_one_half]
[/av_layout_row]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' custom_class='' av_uid='']
<h4 style="text-align: center;">More Solutions</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 style="text-align: center;"><span class="lower">z</span>/OS Security & Compliance Software</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">Check out the latest SDS mainframe security software solutions.  These popular products also offer relevant and significant compliance assistance on z/OS.</p>
[/av_textblock]

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/vftp-ssh/">Secure FTP for z/OS</a></li>
 	<li><a href="/security-software/e-business-server/">Encryption of Data at Rest for z/OS</a></li>
 	<li><a href="/security-software/mainframe-siem/">Filter and Deliver z/OS Security Events to any SIEM</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li><a href="/security-software/automatic-mainframe-stig-monitoring/">Automated, Real-Time z/OS STIG Compliance Monitoring</a></li>
 	<li><a href="/application-access-modernization/virtel-web-access/">Secure, Browser-Based 3270 TE</a></li>
</ul>
[/av_textblock]

[/av_one_half][av_button label='z/OS Security & Compliance' link='page,15555' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_cell_one_half][av_cell_one_half vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#bf1a2d' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/binary-security-red-banner.jpg' attachment='21106' attachment_size='full' background_attachment='scroll' background_position='bottom center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' custom_class='' av_uid='']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' size-text='' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='popmake-23747' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:35:"051319-careers-example-job-and-none";s:18612:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' id='' color='main_color' custom_bg='#acacac' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' custom_class='' av_uid='av-41p97a']

[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_display='' custom_class='' av_uid='av-12g9aye']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='av-10sa3h2']
<h1 class="secondary">SDS | Career Opportunities</h1>
[/av_textblock]

[av_textblock size='20' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-zq0kfa' custom_class='' admin_preview_bg='']
<h2 class="description">Current opening: z/OS Systems Programmer</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_display='av-hide-on-mobile' custom_class='' av_uid='av-xfn8vq']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' custom_class='' av_uid='av-38r5rq'][/av_image]

[/av_one_third][/av_section][av_section min_height='' min_height_px='500px' padding='small' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-u17o1i' custom_class='']
[av_one_full first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-sedm1i' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-r4fdkm' custom_class='' admin_preview_bg='']
<h4>Contact Information:</h4>
While there are no specific job openings available, SDS is always looking for qualified people to submit resumes.

Please send confidential resume to <a href="mailto:confidential@sdsusa.com">confidential@sdsusa.com</a>
[/av_textblock]

[/av_one_full][av_one_full first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-asfiu' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-jr889zsu' custom_class='' admin_preview_bg='']
<hr />

<h4 class="nocaps">Software Diversified Services: Quality Software since 1982</h4>
SDS delivers comprehensive, affordable mainframe and distributed software with a focus on cybersecurity and compliance. Hundreds of organizations worldwide, including many Fortune 500 companies, rely on SDS software. Our expert development and award-winning technical support teams are based in Minneapolis, MN.

SDS recognizes that employees are our most important resource. We have an excellent company culture with flexible work policies for work/life balance.

SDS is a private company that provides a supportive employee atmosphere and a comprehensive benefits package.
<ul>
 	<li>Great Company Culture that recognizes employees are the most valuable resource</li>
 	<li>Flexible work polices for work/life balance, including 4-day summer work weeks</li>
 	<li>Competitive compensation package: 401K plan with company match, comprehensive benefits package including Health, Dental, short/long term disability and Life Insurance</li>
</ul>
[/av_textblock]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='small' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-u17o1i' custom_class='']
[av_one_full first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-sedm1i' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-r4fdkm' custom_class='' admin_preview_bg='']
<h4 class="nocaps">Job Description:</h4>
<b>Mainframe Developer</b>
<h4 class="nocaps">Job Overview:</h4>
Software Diversified Services (SDS) is seeking a full-time talented and motivated mainframe developer to support and add to enterprise-class applications. You will join an expert team that develops, supports, and sells multi-platform software throughout the USA and worldwide.
[/av_textblock]

[/av_one_full][av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='5px,0px' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-jr88jzon' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-jr88e8v9' custom_class='' admin_preview_bg='']
<h4 class="nocaps">Requirements</h4>
<ul>
 	<li>Strong experience developing in HLASM for z/OS</li>
 	<li>Experience developing and supporting commercial software for enterprise environments</li>
 	<li>A strong grasp of the principles of software development in a multiprocessing, multitasking environment</li>
 	<li>The ability to communicate clearly, both in writing and orally</li>
 	<li>A readiness and ability to work alone or as a team member</li>
 	<li>A customer-centric point of view</li>
 	<li>Strong problem-solving skills</li>
 	<li>Proven working experience (8+ years) in software development</li>
 	<li>Ability to refine collected information, eliminate extraneous data, and focus on the root cause of the issue</li>
 	<li>Experience managing multiple issues</li>
</ul>
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-3i6vpi']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-jr88eoyp' custom_class='' admin_preview_bg='']
<h4 class="nocaps">Preferred</h4>
<ul>
 	<li>Programming using access registers and data spaces</li>
 	<li>Programming in 64-bit address mode</li>
 	<li>Bachelor's degree, preferably in Computer Science, Engineering, or equivalent</li>
</ul>
<h4 class="nocaps">Helpful</h4>
<ul>
 	<li>Facility with TCP/IP & CICS concepts</li>
 	<li>Some socket programming experience</li>
 	<li>C/C++ knowledge</li>
 	<li>Java experience</li>
 	<li>Understanding of VTAM, z/VM, and z/VSE</li>
</ul>
[/av_textblock]

[/av_one_half][av_one_full first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='av-asfiu' custom_class='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-jr889zsu' custom_class='' admin_preview_bg='']
<h4 class="nocaps">Contact Information:</h4>
Please send confidential resume to <a href="mailto:confidential@sdsusa.com?subject=MainframeDeveloper">confidential@sdsusa.com</a>

<hr>

*Even if current openings aren't a fit for you, SDS is always looking for qualified people to submit resumes.
<h4><img class="aligncenter wp-image-10979" src="https://sdsusastg.wpenginepowered.com/wp-content/uploads/SDS-logo-quality-mainframe.png" alt="SDS - Quality Mainframe Software since 1982" width="40%" /></h4>
Software Diversified Services delivers comprehensive, affordable mainframe and distributed software with a focus on cybersecurity and compliance. Hundreds of organizations worldwide, including many Fortune 500 companies, rely on SDS software. Our expert development and award-winning technical support teams are based in Minneapolis, MN.

Our products focus on the mainframe market and are backed by extraordinary depth of technical knowledge. SDS is a private company that provides a supportive employee atmosphere and a comprehensive benefits package.
<ul>
 	<li>Great Company Culture that recognizes employees are the most valuable resource</li>
 	<li>Flexible work polices for work/life balance, including 4-day summer work weeks</li>
 	<li>Competitive compensation package: 401K plan with company match, comprehensive benefits package including Health, Dental, short/long term disability and Life Insurance</li>
</ul>
[/av_textblock]

[/av_one_full]
[/av_section]

[av_layout_row border='' min_height='0' color='main_color' mobile='av-flex-cells' id='gridrow' custom_class='' av_uid='av-p053ty']
[av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#7f7f7f' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/photo-webinar-code.jpg' attachment='329' attachment_size='full' background_attachment='scroll' background_position='center center' background_repeat='stretch' link='' linktarget='' link_hover='' mobile_display='' av_uid='av-8fc92' custom_class='']

[/av_cell_one_half][av_cell_one_half vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#7f7f7f' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='av-lvqoja' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='av-k1ma3a']
<h4 style="text-align: center;">Resources</h4>
[/av_textblock]

[av_hr class='invisible' height='10' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='av-ioivjq']

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='av-i66q46']
<h2 style="text-align: center;">About SDS</h2>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av_uid='av-f8kn46']
<p style="text-align: center;">View additional company information here. There is information about acquisitions, career opportunities, distributors, upcoming events, and more.</p>
[/av_textblock]

[av_button label='Visit Resources Page' link='page,2428' link_target='' size='large' position='center' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='light' custom_bg='#444444' custom_font='#ffffff' av_uid='av-dhs9nq']

[/av_cell_one_half]
[/av_layout_row]

[av_section min_height='' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='demotrial' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-cgxex0' custom_class='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='av-beuqs4']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='av-8gyl4k']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-7vic78' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='av-5907ck' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' link='page,11' link_target='' size='large' position='center' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='dark' custom_bg='#444444' custom_font='#ffffff' av_uid='av-4ykh44' custom_class='' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='av-25ccuc']

[/av_one_fifth]
[/av_section]";s:37:"052919-4code-blocks-merging-tab-pages";s:2805:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='hidecode' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='av-jmbpxu5n' custom_class='']
[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' av_uid='av-jlzilk31' custom_class='hide']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="2"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/security-software/vftp-ssh/webinar/#short-videos',
			  '_self'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' av_uid='av-jlzilk31' custom_class='hide']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="3"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/security-software/vftp-ssh/webinar/',
			  '_self'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' av_uid='av-jlzilk31' custom_class='hide']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="4"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/productdocs/VFTP-SSH-datasheet.pdf',
			  '_blank'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]

[av_codeblock wrapper_element='' wrapper_element_attributes='' codeblock_type='' deactivate_shortcode='aviaTBdeactivate_shortcode' av_uid='av-jlzilk31' custom_class='hide']
<script>
(function($){
	function a() {
		var download = $('.av-section-tab-title[data-av-tab-section-title="5"]');

		download.on('click', function(e) {
			e.preventDefault();
			window.open(
			  'https://sdsusastg.wpenginepowered.com/security-software//vftp-ssh/resources/',
			  '_self'
			);
		});
	}

	a();
})(jQuery);
</script>
[/av_codeblock]
[/av_section]";s:30:"CAFC 56 first day support post";s:18053:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='' admin_preview_bg='']
<h1 class="secondary">CAFC 5.6.00 Available for Day One Support of CICS/TS 5.6</h1>
[/av_textblock]

[av_textblock size='20' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="description">June 12, 2020</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' id='' custom_class='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='small' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_fifth first min_height='av-equal-height-column' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' av_uid='' admin_preview_bg='']
<em><a href="/cics-management/cafc/">CAFC</a>, an SDS CICS Management Product, offers Day One Support for CICS/TS 5.6.</em>
<p style="text-align: right;">Lori Kettles, 763-571-9000, <a href="mailto:info@sdsusa.com?subject=CAFC56PR" target="_blank" rel="noopener">info@sdsusa.com</a></p>

<b class="black">MINNEAPOLIS, MN – June 12, 2020</b> – Software Diversified Services (SDS) is very pleased to announce a new release of CICS Application File Control, CAFC 5.6.00, is Generally Available.

This accomplishes your expectations of SDS offering day one support for IBM CICS Transaction Server for z/OS, CICS/TS 5.6, which became Generally Available today, June 12, 2020.
<h4 class="nocaps">CAFC Customer Notes</h4>
To download CAFC 5.6.00, you will need an updated access key. These 5.6.00 access keys have been emailed to customers. Please contact support if your team didn't receive a new CAFC download access key.

Previous CAFC download access keys will not work to download CAFC 5.6+ from the SDS website. However, those keys will continue to work for the corresponding versions' maintenance releases and documentation.

During the download process, please download each of the files available. The documentation is no longer part of the product distribution file.

CAFC customers can download CAFC 5.6.00 through the <a href="https://support.sdsusa.com/downloads/" target="_blank" rel="noopener">SDS downloads webpage</a>.

<hr />

<h4 class="nocaps">What’s new in CAFC 5.6.00?</h4>
<ul>
 	<li>Support for CICS/TS 5.2 through 5.6.</li>
 	<li>New, customizable GRPNAME that allows routing to multiple CICS APPLIDs with a single command.</li>
 	<li>New CAFC CICS internal trace wrap and customizable trace output destinations.</li>
 	<li>New LU6.2 customizable connection wait time option.</li>
 	<li>Enhanced CAFC RLS processing with additional customizable options.</li>
</ul>
For a complete list of enhancements and fixes, please see the What’s New PDF, which is available in the documentation package at the <a href="https://support.sdsusa.com/downloads/" target="_blank" rel="noopener">SDS downloads webpage</a>.

<hr />

<h4 class="nocaps">Unsure which CAFC version is compatible with your version of CICS/TS?</h4>
<b>*If you’d like to run the new CICS/TS 5.6, please download CAFC 5.6.00.</b>

Please take a look at the updated CAFC-CICS matrix below if you're unsure which version(s) of CAFC will work with your CICS/TS level, z/OS level, or IBM Processor.

With the release of CAFC 5.6.00, we have scheduled the CAFC 5.4.00 End of Service date for June 12, 2021.

<img src="https://support.sdsusa.com/_images/cafc-cics-version-matrix.png" />
<h4 class="nocaps">Thank you for using CAFC,</h4>
<h3 class="nocaps">The Entire SDS Team</h3>

<hr />
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_third first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/SDS-logo-quality-mainframe.png' attachment='10979' attachment_size='full' align='center' styling='no-styling' hover='' link='page,11' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third][av_one_third min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_third]
[/av_section]

[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
Founded in 1982, Software Diversified Services delivers comprehensive, affordable mainframe and distributed software with a focus on cybersecurity and compliance. Hundreds of organizations worldwide, including many Fortune 500 companies, rely on SDS software. Our expert development and award-winning technical support teams are based in Minneapolis, MN. To learn more, please visit <a href="https://sdsusastg.wpenginepowered.com">sdsusastg.wpenginepowered.com</a>.
[/av_textblock]

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="darktrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#525252' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='dark' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-2116' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";s:25:"Landing Page Template-VSA";s:44669:"[av_section min_height='' min_height_pc='25' min_height_px='500px' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' padding='default' custom_margin='0px' custom_margin_sync='true' av-desktop-custom_margin='' av-desktop-custom_margin_sync='true' av-medium-custom_margin='' av-medium-custom_margin_sync='true' av-small-custom_margin='' av-small-custom_margin_sync='true' av-mini-custom_margin='' av-mini-custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' custom_arrow_bg='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' css_position_z_index='' av-desktop-css_position_z_index='' av-medium-css_position_z_index='' av-small-css_position_z_index='' av-mini-css_position_z_index='' id='' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_two_third first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='' padding='' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='fade-in' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h1>Are Your Security Gaps Putting Your Bank at Risk?</h1>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Download the infographic revealing the seven critical blind spots that could cost your institution millions</h3>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' link_dynamic='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_one_fourth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="text-align: center;">$4.88M</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Average Data Breach Cost
(IBM 2024)</h4>
[/av_textblock]
[/av_one_fourth]

[av_one_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="text-align: center;">61%</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Infrastructure Leaders Use Mainframe Data</h4>
[/av_textblock]
[/av_one_fourth]

[av_one_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="text-align: center;">$10.4T</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">US Card Annual Transaction Volume</h4>
[/av_textblock]
[/av_one_fourth]

[av_one_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="text-align: center;">$2.0M</h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h4 style="text-align: center;">Annual SOX Compliance Costs (Large Banks)</h4>
[/av_textblock]
[/av_one_fourth]

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="aWBg0w aZskFA u16U_g mKhvSg">Why Financial Leaders Need This Intelligence</h3>
<div class="aWBg0w aZskFA u16U_g mKhvSg">
<ul class="_8k16_w">
 	<li>
<p class="whitespace-normal break-words"><strong>1. Mainframe Security Blind Spots (3 bullets):</strong></p>

<ul class="[&:not(:last-child)_ul]:pb-1 [&:not(:last-child)_ol]:pb-1 list-disc space-y-1.5 pl-7">
 	<li class="whitespace-normal break-words"><strong>Unmonitored Privileged Access</strong> - RACF administrators and database users with ultimate access</li>
 	<li class="whitespace-normal break-words"><strong>Transaction Processing Gaps</strong> - CICS systems processing millions of transactions without proper monitoring</li>
 	<li class="whitespace-normal break-words"><strong>Batch Job Vulnerabilities</strong> - Critical nightly processes running unmonitored</li>
</ul>
<p class="whitespace-normal break-words"><strong>2. Compliance Challenges (3 bullets):</strong></p>

<ul class="[&:not(:last-child)_ul]:pb-1 [&:not(:last-child)_ol]:pb-1 list-disc space-y-1.5 pl-7">
 	<li class="whitespace-normal break-words"><strong>SOX Audit Failures</strong> - $2M compliance costs with unmonitored access creating audit findings</li>
 	<li class="whitespace-normal break-words"><strong>Incomplete Audit Trails</strong> - Gaps in mainframe activity tracking exposing banks to penalties</li>
 	<li class="whitespace-normal break-words"><strong>Data Governance Violations</strong> - Inability to prove data access controls are working</li>
</ul>
<p class="whitespace-normal break-words"><strong>3. Solution - VSA (2 bullets):</strong></p>

<ul class="[&:not(:last-child)_ul]:pb-1 [&:not(:last-child)_ol]:pb-1 list-disc space-y-1.5 pl-7">
 	<li class="whitespace-normal break-words"><strong>Real-Time Mainframe Monitoring</strong> - Comprehensive visibility with automated threat detection</li>
 	<li class="whitespace-normal break-words"><strong>Automated Compliance Reporting</strong> - Audit-ready reports reducing compliance costs</li>
</ul>
</li>
</ul>
</div>
<p class="aWBg0w aZskFA u16U_g mKhvSg">Would you like to learn more about how the VSA solution can be implemented in banking environments?</p>
[/av_textblock]
[/av_one_full]

[av_one_fourth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/VSA-Bank-Infographic-1200-x-1600-px.jpg' attachment='24621' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='medium' styling='' box_shadow='outside' box_shadow_width='1' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' link_dynamic='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]
[/av_one_fourth]

[av_three_fourth min_height='' vertical_alignment='av-align-top' space='' row_boxshadow='' row_boxshadow_width='10' row_boxshadow_color='' custom_margin='' margin='0px' av-desktop-margin='' av-medium-margin='' av-small-margin='' av-mini-margin='' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' min_col_height='' padding='' av-desktop-padding='' av-medium-padding='' av-small-padding='' av-mini-padding='' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_flip='' svg_div_top_invert='' svg_div_top_front='' svg_div_top_opacity='' svg_div_top_preview='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_flip='' svg_div_bottom_invert='' svg_div_bottom_front='' svg_div_bottom_opacity='' svg_div_bottom_preview='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight='' highlight_size='' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location='' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location='' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location='' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location='' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location='' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']
[av_contact title='Download the Complete Infographic' button='Download Infogrpahic' on_send='redirect' sent='Thank you!' link='manually,https://sdsusa.com//productdocs/VSA Bank Infographic.pdf' with_errors='yes' captcha='' captcha_theme='light' captcha_size='normal' captcha_score='0.5' email='' from_email='' subject='' autoresponder_email='' autoresponder_reply_to='' autoresponder_subject='' autorespond='' autorespond_after='' form_align='' color='' heading_tag='' heading_class='' alb_description='' id='' custom_class='' template_class='' aria_label='Contact Form' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_contact_field label='Name' type='text' check='is_empty' options='' multi_select='' date_limit='' av_contact_preselect='' element_display='' width='' headline_tag='h3' av_uid='' sc_version='1.0'][/av_contact_field]
[av_contact_field label='E-Mail' type='text' check='is_email' options='' multi_select='' date_limit='' av_contact_preselect='' element_display='' width='' headline_tag='h3' av_uid='' sc_version='1.0'][/av_contact_field]
[av_contact_field type='text' label='Company' options='' check='is_empty' element_display='' width='' headline_tag='h3' av_uid='' sc_version='1.0' multi_select='' date_limit='' av_contact_preselect=''][/av_contact_field]
[/av_contact]
[/av_three_fourth]";s:24:"Opening-Three-Cards_2025";s:40987:"[av_layout_row min_height_percent='50' min_height_pc='25' min_height='80vh' border='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' color='main_color' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' mobile='av-flex-cells' mobile_breaking='av-break-at-tablet' mobile_column_order='' av-medium-hide='aviaTBav-medium-hide' av-small-hide='aviaTBav-small-hide' av-mini-hide='aviaTBav-mini-hide' id='' custom_class='home-3-card-section2025' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='360px' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#e5e4e4' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='resource-card' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='left' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="text-align: left;"><span style="font-size: 25px;">Webinar</span></h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#0a0a0a' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: left; margin-bottom: 40px;">Watch this 30-minute webinar focusing on the capabilities of Virtel Screen Recordings.</p>
[/av_textblock]

[av_button label='WATCH NOW' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' title_attr='' button_type='' link='manually,https://www.sdsusa.com/application-access-modernization/virtel-screen-redesigner/vsr-webinar/' link_dynamic='' link_target='' download_file='https://' attachment='' attachment_size='' downloaded_file_name='' size='medium' position='left' label_display='' size-text='17' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='color_options_advanced' color='white' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='dark' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='black' btn_custom_font='#ffffff' btn_color_font_hover='white' btn_custom_font_hover='#ffffff' border='none' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_full][av_four_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='auto' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='180,-50,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='relative' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='home-text-column-align' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/Man-with-a-headset-on-talking-on-a-video-work-call-scaled.jpg' attachment='24945' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' link_dynamic='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='absolute' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_four_fifth][/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='360px' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#e5e4e4' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='resource-card' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#0a0a0a' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3><strong><span style="font-size: 25px;">Solutions</span></strong></h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#0a0a0a' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: left;">SDS offers a wide range of products focusing primarily on mainframe security and compliance and multi-platform encryption.</p>
[/av_textblock]

[av_button label='VIEW ALL SOLUTIONS' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' title_attr='' button_type='' link='page,16' link_dynamic='' link_target='' download_file='https://' attachment='' attachment_size='' downloaded_file_name='' size='medium' position='left' label_display='' size-text='17' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='color_options_advanced' color='white' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='dark' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='dark' btn_custom_bg_hover='#444444' btn_color_font='black' btn_custom_font='#ffffff' btn_color_font_hover='black' btn_custom_font_hover='#ffffff' border='none' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='none' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_full][av_four_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='auto' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='180,-50,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='home-text-column-align' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/Red-Gradient-background-with-cartoon-locks-throughout-scaled.jpg' attachment='24946' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' link_dynamic='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='absolute' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_four_fifth][/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='' background_gradient_color2='' background_gradient_color3='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' link_dynamic='' linktarget='' title_attr='' link_hover='' mobile_display='' mobile_col_pos='0' custom_class='' template_class='' av_uid='' sc_version='1.0']

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='360px' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='#e5e4e4' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='resource-card' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="text-align: left;"><span style="font-size: 25px;">SECURE z/OS FTP</span></h3>
[/av_textblock]

[av_textblock fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' textblock_styling_align='' textblock_styling='' textblock_styling_gap='' textblock_styling_mobile='' size='' av-desktop-font-size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#0a0a0a' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' fold_timer='' z_index_fold='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<p style="text-align: left;">This popular solution cures any z/OS FTP compliance headaches you may have while providing multiple layers of security for file transfers.</p>
[/av_textblock]

[av_button label='FIND OUT MORE' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' title_attr='' button_type='' link='manually,https://www.sdsusa.com/security-software/vftp-ssh/' link_dynamic='' link_target='' download_file='https://' attachment='' attachment_size='' downloaded_file_name='' size='medium' position='left' label_display='' size-text='17' av-desktop-font-size-text='' av-medium-font-size-text='' av-small-font-size-text='' av-mini-font-size-text='' margin='' margin_sync='true' padding='' padding_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-margin='' av-small-margin_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-margin='' av-mini-margin_sync='true' av-mini-padding='' av-mini-padding_sync='true' color_options='color_options_advanced' color='white' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='dark' btn_custom_grad_direction='vertical' btn_custom_grad_1='#000000' btn_custom_grad_2='#ffffff' btn_custom_grad_3='' btn_custom_grad_opacity='0.7' btn_custom_bg='#444444' btn_color_bg_hover='dark' btn_custom_bg_hover='#444444' btn_color_font='black' btn_custom_font='#ffffff' btn_color_font_hover='black' btn_custom_font_hover='#ffffff' border='none' border_width='' border_width_sync='true' border_color='' border_radius='' border_radius_sync='true' box_shadow='none' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' hover_opacity='' sonar_effect_effect='' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' css_position='' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_one_full][av_four_fifth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_width='10' row_boxshadow_color='' margin='0px' margin_sync='true' av-desktop-margin='' av-desktop-margin_sync='true' av-medium-margin='' av-medium-margin_sync='true' av-small-margin='' av-small-margin_sync='true' av-mini-margin='' av-mini-margin_sync='true' mobile_breaking='' mobile_column_order='' border='' border_style='solid' border_color='' radius='' radius_sync='true' min_col_height='auto' padding='32' padding_sync='true' av-desktop-padding='' av-desktop-padding_sync='true' av-medium-padding='' av-medium-padding_sync='true' av-small-padding='' av-small-padding_sync='true' av-mini-padding='' av-mini-padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' fold_type='' fold_height='' fold_more='Read more' fold_less='Read less' fold_text_style='' fold_btn_align='' column_boxshadow_width='10' column_boxshadow_color='' background='bg_color' background_color='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' src_dynamic='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' fold_overlay_color='' fold_text_color='' fold_btn_color='theme-color' fold_btn_bg_color='' fold_btn_font_color='' size-btn-text='' av-desktop-font-size-btn-text='' av-medium-font-size-btn-text='' av-small-font-size-btn-text='' av-mini-font-size-btn-text='' animation='' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' fold_timer='' z_index_fold='' css_position='absolute' css_position_location='180,-50,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' link='' link_dynamic='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' mobile_col_pos='0' id='' custom_class='home-text-column-align' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/Labtop-with-a-cartoon-lock-over-top-of-it-scaled.jpg' attachment='24947' attachment_size='full' src_dynamic='' copyright='' caption='' image_size='' styling='' box_shadow='none' box_shadow_width='10' box_shadow_color='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' link='' link_dynamic='' target='' animation='no-animation' animation_duration='' animation_custom_bg_color='' animation_z_index_curtain='100' parallax_parallax='' parallax_parallax_speed='' av-desktop-parallax_parallax='' av-desktop-parallax_parallax_speed='' av-medium-parallax_parallax='' av-medium-parallax_parallax_speed='' av-small-parallax_parallax='' av-small-parallax_parallax_speed='' av-mini-parallax_parallax='' av-mini-parallax_parallax_speed='' hover='' blur_image='' grayscale_image='' fade_image='' appearance='' css_position='absolute' css_position_location=',,,' css_position_z_index='' av-desktop-css_position='' av-desktop-css_position_location=',,,' av-desktop-css_position_z_index='' av-medium-css_position='' av-medium-css_position_location=',,,' av-medium-css_position_z_index='' av-small-css_position='' av-small-css_position_location=',,,' av-small-css_position_z_index='' av-mini-css_position='' av-mini-css_position_location=',,,' av-mini-css_position_z_index='' transform_perspective='' transform_rotation=',,,' transform_scale=',,' transform_skew=',' transform_translate=',,' av-desktop-transform_perspective='' av-desktop-transform_rotation=',,,' av-desktop-transform_scale=',,' av-desktop-transform_skew=',' av-desktop-transform_translate=',,' av-medium-transform_perspective='' av-medium-transform_rotation=',,,' av-medium-transform_scale=',,' av-medium-transform_skew=',' av-medium-transform_translate=',,' av-small-transform_perspective='' av-small-transform_rotation=',,,' av-small-transform_scale=',,' av-small-transform_skew=',' av-small-transform_translate=',,' av-mini-transform_perspective='' av-mini-transform_rotation=',,,' av-mini-transform_scale=',,' av-mini-transform_skew=',' av-mini-transform_translate=',,' mask_overlay='' mask_overlay_shape='blob' mask_overlay_size='contain' mask_overlay_scale='100%' mask_overlay_position='center center' mask_overlay_repeat='no-repeat' mask_overlay_rotate='' mask_overlay_rad_shape='circle' mask_overlay_rad_position='center center' mask_overlay_opacity1='0' mask_overlay_opacity2='1' mask_overlay_opacity3='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_four_fifth][/av_cell_one_third]
[/av_layout_row]";s:10:"SHARE 2020";s:42052:"[av_section min_height='' min_height_px='500px' padding='no-padding' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' color='main_color' background='bg_color' custom_bg='#acacac' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top center' repeat='stretch' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' av_element_hidden_in_editor='0' av_uid='' custom_class='']
[av_two_third first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='fade-in' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h1 class="secondary">Highlights | SHARE Fort Worth 2020</h1>
[/av_textblock]

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="description">February 10, 2020 (updated Feb. 28, 2020)
Thank you for stopping by the SDS booth at the Tech Expo.</h2>
[/av_textblock]

[/av_two_third][av_one_third min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='av-hide-on-mobile' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/sds.png' attachment='7918' attachment_size='full' align='center' styling='' hover='' link='' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='no-animation' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[/av_one_third]
[/av_section]

[av_tab_section transition='av-tab-slide-transition' padding='small' tab_pos='av-tab-above-content' content_height='av-tab-content-auto' tab_padding='none' initial='1' av_element_hidden_in_editor='0' av_admin_tab_active='6' bg_color='#7f7f7f' color='#ffffff' id='' custom_class='' aria_label='' av_uid='']
[av_tab_sub_section tab_title='Info & News' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_fifth first min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
It was great to see everyone at SHARE 2020 in Fort Worth, Texas this February! Every year, we look forward to engaging with all of you at SHARE. This winter, we had some excellent conversations with partners, existing users, and others in the mainframe industry. Thank you to everyone who stopped by the SDS booth!
<h3 class="nocaps">News and Updates</h3>
We are continuing to add new features and enhancements to the software solutions we offer. The bulk of our ongoing product development projects at SDS center around our security and compliance solutions.

The new releases for both SDS E-Business Server<sup>®</sup> and VitalSigns SIEM Agent<sup>™</sup> for z/OS contain significant enhancements. We've also been enhancing our <a href="https://sdsusastg.wpenginepowered.com/mainframe-network-management/">VitalSigns suite of products</a> to ensure they continue to be the best-in-class z/OS monitors our users expect.

For more information regarding our mainframe solutions, see our categories listed below or our brand new <a href="https://sdsusastg.wpenginepowered.com/products/interactive-toolkit/">mainframe solution toolkit</a>, an aid to quickly identify solutions offered by SDS.
<h4 class="nocaps">SDS Press Release for SHARE Fort Worth 2020</h4>
<a href="https://sdsusastg.wpenginepowered.com/blog/news/vsa-listed-as-trend-setting-product-for-2020-by-dbta/">SDS VitalSigns SIEM Agent<sup>™</sup> for z/OS Named 2020 Trend-Setting Product by DBTA</a> - this press release was available via the SHARE pressroom during the event.
[/av_textblock]

[av_blog blog_type='posts' categories='19' link='category' date_filter='date_filter' date_filter_start='2020/02/23' date_filter_end='2020/02/26' date_filter_format='yy/mm/dd' blog_style='bloglist-excerpt' bloglist_width='' columns='3' contents='excerpt' content_length='content' preview_mode='auto' image_size='portfolio' items='1' offset='0' paginate='yes' conditional='' av-desktop-hide='aviaTBav-desktop-hide' av-medium-hide='aviaTBav-medium-hide' av-small-hide='aviaTBav-small-hide' av-mini-hide='aviaTBav-mini-hide' custom_class='' av_uid='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[/av_one_fifth][/av_tab_sub_section][av_tab_sub_section tab_title='Automate z/OS STIGs' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="nocaps">IronSphere for z/OS</h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock size='15' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li>Automate Tedious z/OS STIG Compliance Work</li>
 	<li>More Manageable Compliance Mandates</li>
 	<li>Find & Display Security Vulnerabilities</li>
 	<li>Remediation Steps Delivered in GUI</li>
 	<li>Help for Auditors; Painless Future Audits</li>
 	<li>Even Stronger Mainframe Security</li>
</ul>
[/av_textblock]

[av_button label='IronSphere page' link='page,7173' link_target='' size='large' position='left' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/332435591' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Secure 3270 TE+' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='tab24' av_uid='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="nocaps">Virtel<sup>®</sup> Web Access</h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock size='15' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<ul>
 	<li>Ultra-Thin Client Architecture promotes Security, Mobility, and Agility</li>
 	<li>Replace your 3270 Terminal Emulator and Save up to 80%</li>
 	<li>Serve 3270 Screens on Browser over Encrypted HTTPS Connections</li>
 	<li>End Dependence on Unsafe Applets and Plugins: Java plugin is NOT used</li>
 	<li>Easy Deployment and Eliminate Need for Workstation-level Support and Updates</li>
</ul>
[/av_textblock]

[av_button label='VWA page' link='page,4289' link_target='' size='large' position='left' label_display='' title_attr='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_hr class='invisible' height='20' shadow='no-shadow' position='center' custom_border='av-border-thin' custom_width='50px' custom_border_color='' custom_margin_top='30px' custom_margin_bottom='30px' icon_select='yes' custom_icon_color='' icon='ue808' font='entypo-fontello' id='' custom_class='' av_uid='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<h2 class="nocaps">Virtel<sup>®</sup> Web Suite</h2>
[/av_textblock]

[av_textblock size='15' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<ul>
 	<li>3 Solutions that can offer a <a href="https://sdsusastg.wpenginepowered.com/application-access-modernization/2019-webisode-series/">Security-conscious Digital Transformation</a></li>
 	<li>Modernize 3270 Screens</li>
 	<li>Full z/OS Web Integration; API-based Microservices</li>
</ul>
[/av_textblock]

[av_button label='VWS page' link='page,101' link_target='' size='large' position='left' label_display='' title_attr='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' id='' custom_class='' av_uid='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' link='' linktarget='' link_hover='' padding='0px' border='' border_color='' radius='0px' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/363798609' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' id='' custom_class='' av_uid='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='Secure z/OS FTP' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="nocaps">The VFTP-SSH Collaboration</h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li>Automatic FTP to SFTP Conversion</li>
 	<li>No JCL Changes</li>
 	<li>Pass FTP-related Compliance Requirements</li>
 	<li>Visibility of all Transfers to/from Mainframe</li>
 	<li>Multi-layered Data Transfer Security</li>
 	<li>Integrate z/OS FTP Server with your SAF for Added Security</li>
</ul>
[/av_textblock]

[av_button label='VFTP-SSH page' link='page,1199' link_target='' size='large' position='left' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/312778955' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='z/OS Predictive Alerts' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='' av_uid='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="nocaps">ConicIT<sup>®</sup></h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<ul>
 	<li>Expert z/OS Performance Monitoring System</li>
 	<li>Uses Predictive Machine Learning</li>
 	<li>Helps to Mitigate Loss of Experienced z/OS Talent</li>
 	<li>Consolidates and Unifies Performance Data</li>
 	<li>Predicts and Alerts when Demand Exceeds Capacity</li>
 	<li>Reduces MTTR and Increases MTBF</li>
</ul>
[/av_textblock]

[av_button label='ConicIT page' link='page,1425' link_target='' size='large' position='left' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='' space='' custom_margin='' margin='0px' row_boxshadow='' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' padding='0px' highlight='' highlight_size='' border='' border_color='' radius='0px' column_boxshadow='' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='']

[av_video src='https://vimeo.com/203901097' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section][av_tab_sub_section tab_title='z/OS SIEM Agent' vertical_align='middle' icon_select='no' icon='ue800' font='entypo-fontello' tab_image='' tab_image_style='' color='' background_color='' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' custom_class='tab24' av_uid='']

[av_one_half first min_height='av-equal-height-column' vertical_alignment='av-align-middle' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' row_boxshadow_color='' row_boxshadow_width='10' link='' linktarget='' link_hover='' title_attr='' alt_attr='' padding='0px,0px,0px,50px' highlight_size='1.1' border='' border_color='' radius='0px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' id='' custom_class='' av_uid='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="nocaps">VitalSigns SIEM Agent<sup>™</sup> for z/OS</h2>
<h3 class="nocaps">Key Benefits</h3>
[/av_textblock]

[av_textblock size='15' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<ul>
 	<li>Real-Time Delivery of Important z/OS Event Records to SIEM</li>
 	<li>Automates z/OS Event Logging Process</li>
 	<li>Helps Achieve Security Compliance for z/OS</li>
 	<li>Alerts when Threat/Breach is Detected</li>
 	<li>Integrates well with any SIEM; Certified CEF and LEEF formats</li>
 	<li>Filters out Noise; Save Resources</li>
</ul>
[/av_textblock]

[av_button label='VSA page' link='page,1665' link_target='' size='large' position='left' label_display='' icon_select='yes' icon_hover='aviaTBicon_hover' icon='ue875' font='entypo-fontello' color='theme-color' custom_bg='#444444' custom_font='#ffffff' av_uid='' custom_class='' admin_preview_bg='']

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px,0px,0px,0px' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']

[av_video src='https://vimeo.com/300932649' mobile_image='' attachment='' attachment_size='' format='16-9' width='16' height='9' conditional_play='' av_uid='' custom_class='']

[/av_one_half][/av_tab_sub_section]
[/av_tab_section]

[av_one_full first min_height='' vertical_alignment='av-align-top' space='' custom_margin='aviaTBcustom_margin' margin='0px' margin_sync='true' link='' linktarget='' link_hover='' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background='bg_color' background_color='' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='' mobile_breaking='' mobile_display='' av_uid='' custom_class='']
[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 style="text-align: center;">SDS Solutions</h3>
[/av_textblock]
[/av_one_full]

[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='av-break-at-tablet' av_uid='' custom_class='']
[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#f7f7f7' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-security-compliance.png' attachment='16085' attachment_size='full' align='center' styling='no-styling' hover='' link='page,15555' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='fade-in' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_textblock size='' font_color='custom' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/mainframe-security-compliance/"><span class="lower">z</span>/OS Security & Compliance</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="f7f7f7gray3">
<tbody>
<tr>
<td><a href="/security-software/mainframe-siem/">VitalSigns SIEM Agent<sup>™</sup> for z/OS</a></td>
<td>Integrate mainframe security events into any enterprise SIEM</td>
</tr>
<tr>
<td><a href="/security-software/vftp-ssh/">VFTP-SSH Collaboration</a></td>
<td>Complete FTP security for z/OS; no JCL changes needed</td>
</tr>
<tr>
<td><a href="/security-software/e-business-server/">SDS E-Business Server<sup>®</sup> for z/OS</a></td>
<td>Rock-solid PGP encryption for data at rest</td>
</tr>
<tr>
<td><a href="/security-software/automatic-mainframe-stig-monitoring/">SDS IronSphere for z/OS</a></td>
<td>Automated DISA STIG compliance monitoring for z/OS</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-network.png' attachment='372' attachment_size='full' align='center' styling='no-styling' hover='' link='page,95' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/mainframe-network-management/">Mainframe Network Management</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="e8e8e8gray3">
<tbody>
<tr>
<td><a href="/mainframe-network-management/vftp/">VitalSigns for FTP<sup>™</sup></a></td>
<td>Snap-in security for file transfers to & from z/OS</td>
</tr>
<tr>
<td><a href="/mainframe-network-management/vip/">VitalSigns for IP<sup>™</sup></a></td>
<td>Complete IP monitoring on z/OS</td>
</tr>
<tr>
<td><a href="/mainframe-network-management/vnac/">VitalSigns for NAC<sup>™</sup></a></td>
<td>Replace legacy mainframe network monitoring</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#cacaca' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-mainframe-performance.png' attachment='373' attachment_size='full' align='center' styling='no-styling' hover='' link='page,97' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/mainframe-performance-optimization/">Mainframe Performance & Optimization</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<table class="cacacagray3">
<tbody>
<tr>
<td><a href="/mainframe-performance-optimization/conicit/">ConicIT<sup>®</sup></a></td>
<td>Predictive operations management and analysis for z/OS</td>
</tr>
<tr>
<td><a href="/mainframe-performance-optimization/multiterm/">Multiterm<sup>™</sup> for z/OS, z/VM, & z/VSE</a></td>
<td>Premier session manager for z Series mainframes</td>
</tr>
<tr>
<td><a href="/mainframe-performance-optimization/vitalsigns-z-tuning/">VitalSigns for z Tuning<sup>™</sup></a></td>
<td>System analysis for money-saving performance</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third]
[/av_layout_row]

[av_layout_row border='' min_height_percent='' min_height='0' color='main_color' mobile='av-flex-cells' id='' av_element_hidden_in_editor='0' mobile_breaking='av-break-at-tablet' av_uid='' custom_class='']
[av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#e8e8e8' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-application-access.png' attachment='375' attachment_size='full' align='center' styling='no-styling' hover='' link='page,101' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/application-access-modernization/">Application Access & Modernization</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="e8e8e8gray3">
<tbody>
<tr>
<td><a href="/application-access-modernization/virtel-web-access/">Virtel<sup>®</sup> Web Access</a></td>
<td>Ultra-thin and secure 3270 TE on any device</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-web-modernization/">Virtel<sup>®</sup> Web Modernization</a></td>
<td>Serve host transactions as user-friendly web pages (GUIs)</td>
</tr>
<tr>
<td><a href="/application-access-modernization/virtel-web-integration/">Virtel<sup>®</sup> Web Integration</a></td>
<td>Create interactive bidirectional connections; integrate host & web</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='top' padding='30px' padding_sync='true' background='bg_color' background_color='#cacaca' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='http://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-cics.png' attachment='374' attachment_size='full' align='center' styling='no-styling' hover='' link='page,99' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' av_uid=''][/av_image]

[av_textblock size='' font_color='custom' color='#bf1a2d' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/cics-management/">CICS Management</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<table class="cacacagray3">
<tbody>
<tr>
<td><a href="/cics-management/cafc/">CAFC<sup>™</sup></a></td>
<td>CICS Application File Control system software</td>
</tr>
<tr>
<td><a href="/cics-management/ipcp-plus/">IPCP<sup>™</sup> Plus for z/OS & z/VSE</a></td>
<td>Premier file control utility for z/OS & z/VSE</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third][av_cell_one_third vertical_align='middle' padding='30px' padding_sync='true' background='bg_color' background_color='#f7f7f7' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' background_attachment='scroll' background_position='top left' background_repeat='no-repeat' link='' linktarget='' link_hover='' mobile_display='' av_uid='' custom_class='']

[av_image src='https://sdsusastg.wpenginepowered.com/wp-content/uploads/icon-solution-security.png' attachment='371' attachment_size='full' align='center' styling='no-styling' hover='' link='page,16088' target='' caption='' font_size='' appearance='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' copyright='' animation='fade-in' av_uid='' custom_class='' admin_preview_bg=''][/av_image]

[av_textblock size='' font_color='custom' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h3 class="categoryTitles" style="text-align: center;"><a href="/encryption-ssh-solutions/">Encryption & SSH Solutions</a></h3>
[/av_textblock]

[av_hr class='custom' height='50' shadow='no-shadow' position='center' custom_border='av-border-fat' custom_width='90%' custom_border_color='#acacac' custom_margin_top='5px' custom_margin_bottom='10px' icon_select='no' custom_icon_color='' icon='ue808' font='entypo-fontello' av_uid='' custom_class='' admin_preview_bg='']

[av_textblock size='' font_color='' color='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' id='' custom_class='' av_uid='' admin_preview_bg='']
<table class="f7f7f7gray3">
<tbody>
<tr>
<td><a href="/security-software/e-business-server/">SDS E-Business Server<sup>®</sup></a></td>
<td>Multi-platform PGP encryption for data at rest</td>
</tr>
<tr>
<td><a href="/security-software/tectia-ssh/">Tectia<sup>®</sup> SSH</a></td>
<td>Server and client that secures and encrypts file transfers and more</td>
</tr>
<tr>
<td><a href="/security-software/universal-ssh-key-manager/">Universal SSH Key Manager<sup>®</sup></a></td>
<td>Centralize, simplify, and automate SSH key management</td>
</tr>
</tbody>
</table>
[/av_textblock]

[/av_cell_one_third]
[/av_layout_row]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_margin='0px' custom_margin_sync='true' custom_arrow_bg='' color='main_color' background='bg_color' custom_bg='#bf1a2d' background_gradient_color1='' background_gradient_color2='' background_gradient_direction='vertical' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' id='' custom_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='']
[av_one_fifth first min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth][av_three_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[av_textblock size='' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<h2 class="whitetrial" style="text-align: center;">Free Demo/Trial</h2>
[/av_textblock]

[av_textblock size='24' font_color='custom' color='#ffffff' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' av_uid='' custom_class='' admin_preview_bg='']
<p style="text-align: center;">We offer individualized product demonstrations by request. Your organization can also try SDS Software on your system for 30 days, free of charge.</p>
[/av_textblock]

[av_button label='Request a Free Demo or Trial' icon_select='yes' icon='ue875' font='entypo-fontello' icon_hover='aviaTBicon_hover' link='manually,' link_target='' size='large' position='center' label_display='' title_attr='' color_options='' color='light' custom_bg='#444444' custom_font='#ffffff' btn_color_bg='theme-color' btn_custom_bg='#444444' btn_color_bg_hover='theme-color-highlight' btn_custom_bg_hover='#444444' btn_color_font='theme-color' btn_custom_font='#ffffff' id='' custom_class='popmake-694' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']

[/av_three_fifth][av_one_fifth min_height='' vertical_alignment='av-align-top' space='' margin='0px' margin_sync='true' padding='0px' padding_sync='true' border='' border_color='' radius='0px' radius_sync='true' background_color='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' animation='bottom-to-top' mobile_display='' av_uid='']

[/av_one_fifth]
[/av_section]";}