<?xml version="1.0" encoding="utf-8"?>
<!--
 * Copyright (c) 2006, The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/
-->
<resources>
    <!-- Amount to offset bottom of notification peek window from top of status bar. -->
    <dimen name="peek_window_y_offset">-12dp</dimen>

    <!-- thickness (height) of the navigation bar on phones that require it -->
    <dimen name="navigation_bar_size">@*android:dimen/navigation_bar_height</dimen>
    <!-- Minimum swipe distance to catch the swipe gestures to invoke assist or switch tasks. -->
    <dimen name="navigation_bar_min_swipe_distance">48dp</dimen>

    <!-- thickness (height) of the dead zone at the top of the navigation bar,
         reducing false presses on navbar buttons; approx 2mm -->
    <dimen name="navigation_bar_deadzone_size">12dp</dimen>
    <!-- size of the dead zone when touches have recently occurred elsewhere on screen -->
    <dimen name="navigation_bar_deadzone_size_max">32dp</dimen>

    <!-- Height of notification icons in the status bar -->
    <dimen name="status_bar_icon_size">@*android:dimen/status_bar_icon_size</dimen>

    <!-- Height of the battery icon in the status bar. -->
    <dimen name="status_bar_battery_icon_height">13.0dp</dimen>

    <!-- Width of the battery icon in the status bar. -->
    <dimen name="status_bar_battery_icon_width">8.5dp</dimen>

    <!-- The font size for the clock in the status bar. -->
    <dimen name="status_bar_clock_size">14sp</dimen>

    <!-- The starting padding for the clock in the status bar. -->
    <dimen name="status_bar_clock_starting_padding">7dp</dimen>

    <!-- The end padding for the clock in the status bar. -->
    <dimen name="status_bar_clock_end_padding">0dp</dimen>

    <!-- Starting padding for a left-aligned status bar clock -->
    <dimen name="status_bar_left_clock_starting_padding">0dp</dimen>

    <!-- End padding for left-aligned status bar clock -->
    <dimen name="status_bar_left_clock_end_padding">7dp</dimen>

    <!-- Spacing after the wifi signals that is present if there are any icons following it. -->
    <dimen name="status_bar_wifi_signal_spacer_width">4dp</dimen>

    <!-- Spacing before the airplane mode icon if there are any icons preceding it. -->
    <dimen name="status_bar_airplane_spacer_width">4dp</dimen>

    <!-- The amount to scale each of the status bar icons by. A value of 1 means no scaling. -->
    <item name="status_bar_icon_scale_factor" format="float" type="dimen">1.0</item>

    <dimen name="group_overflow_number_size">@*android:dimen/notification_text_size</dimen>
    <dimen name="group_overflow_number_size_dark">16sp</dimen>
    <dimen name="group_overflow_number_padding">@*android:dimen/notification_content_margin_end</dimen>
    <dimen name="group_overflow_number_extra_padding_dark">@*android:dimen/notification_extra_margin_ambient</dimen>

    <!-- max height of a notification such that the content can still fade out when closing -->
    <dimen name="max_notification_fadeout_height">100dp</dimen>

    <!-- End margin for the RSSI status icon of a device connected via bluetooth. -->
    <dimen name="status_bar_connected_device_signal_margin_end">16dp</dimen>

    <!-- The size of a bluetooth indicator icon that displays next to the RSSI status icon. -->
    <dimen name="status_bar_connected_device_bt_indicator_size">17dp</dimen>

    <!-- Height of a small notification in the status bar-->
    <dimen name="notification_min_height">106dp</dimen>

    <!-- Increased height of a small notification in the status bar -->
    <dimen name="notification_min_height_increased">146dp</dimen>

    <!-- Height of a small notification in the status bar which was used before android N -->
    <dimen name="notification_min_height_legacy">64dp</dimen>

    <!-- Height of a small notification in the status bar which was used before android P -->
    <dimen name="notification_min_height_before_p">92dp</dimen>

    <!-- Height of a large notification in the status bar -->
    <dimen name="notification_max_height">294dp</dimen>

    <!-- Height of an ambient notification on ambient display -->
    <dimen name="notification_ambient_height">400dp</dimen>

    <!-- Height of a heads up notification in the status bar for legacy custom views -->
    <dimen name="notification_max_heads_up_height_legacy">128dp</dimen>

    <!-- Height of a heads up notification in the status bar for custom views before andoid P -->
    <dimen name="notification_max_heads_up_height_before_p">148dp</dimen>

    <!-- Height of a heads up notification in the status bar -->
    <dimen name="notification_max_heads_up_height">162dp</dimen>

    <!-- Height of a heads up notification in the status bar -->
    <dimen name="notification_max_heads_up_height_increased">188dp</dimen>

    <!-- Side padding on the lockscreen on the side of notifications -->
    <dimen name="notification_side_paddings">4dp</dimen>

    <!-- padding between the heads up and the statusbar -->
    <dimen name="heads_up_status_bar_padding">8dp</dimen>

    <!-- heads up elevation that is added if the view is pinned -->
    <dimen name="heads_up_pinned_elevation">16dp</dimen>

    <!-- Height of a messaging notifications with actions at least. Not that this is an upper bound
         and the notification won't use this much, but is measured with wrap_content -->
    <dimen name="notification_messaging_actions_min_height">196dp</dimen>

    <!-- a threshold in dp per second that is considered fast scrolling -->
    <dimen name="scroll_fast_threshold">1500dp</dimen>

    <!-- Height of a the shelf with the notification icons -->
    <dimen name="notification_shelf_height">32dp</dimen>

    <!-- Minimum height of a notification to be interactable -->
    <dimen name="notification_min_interaction_height">40dp</dimen>

    <!-- the padding of the shelf icon container -->
    <dimen name="shelf_icon_container_padding">13dp</dimen>

    <!-- The padding of a notification icon on top to the start of the notification. Used for custom
         views where the distance can't be measured -->
    <dimen name="notification_icon_appear_padding">15dp</dimen>

    <!-- Vertical translation of the shelf during animation that happens after the
    notification panel collapses -->
    <dimen name="shelf_appear_translation">42dp</dimen>

    <!-- Vertical translation of pulsing notification animations -->
    <dimen name="pulsing_notification_appear_translation">10dp</dimen>

    <!-- The amount the content shifts upwards when transforming into the icon -->
    <dimen name="notification_icon_transform_content_shift">32dp</dimen>

    <!-- The padding on the bottom of the notifications on the keyguard -->
    <dimen name="keyguard_indication_bottom_padding">12sp</dimen>

    <!-- Minimum layouted height of a notification in the statusbar-->
    <dimen name="min_notification_layout_height">48dp</dimen>

    <!-- Size of the space to place a notification menu item -->
    <dimen name="notification_menu_icon_size">64dp</dimen>

    <!-- The space around a notification menu item  -->
    <dimen name="notification_menu_icon_padding">20dp</dimen>

    <!-- The vertical space around the buttons in the inline settings -->
    <dimen name="notification_guts_button_spacing">6dp</dimen>

    <!-- Extra horizontal space for properly aligning guts buttons with the notification content -->
    <dimen name="notification_guts_button_side_margin">8dp</dimen>

    <!-- The vertical padding a notification guts button has to fulfill the 48dp touch target -->
    <dimen name="notification_guts_button_vertical_padding">14dp</dimen>

    <!-- The horizontal padding for notification guts buttons-->
    <dimen name="notification_guts_button_horizontal_padding">8dp</dimen>

    <!-- The horizontal space around the buttons in the inline settings -->
    <dimen name="notification_guts_button_horizontal_spacing">8dp</dimen>

    <!-- The height of the header in inline settings -->
    <dimen name="notification_guts_header_height">24dp</dimen>

    <!-- The minimum height for the snackbar shown after the snooze option has been chosen. -->
    <dimen name="snooze_snackbar_min_height">56dp</dimen>

    <!-- The text size of options in the snooze menu. -->
    <dimen name="snooze_option_text_size">14sp</dimen>

    <!-- The padding around options int the snooze menu. -->
    <dimen name="snooze_option_padding">8dp</dimen>

    <!-- size at which Notification icons will be drawn in the status bar -->
    <dimen name="status_bar_icon_drawing_size">15dp</dimen>

    <!-- size at which Notification icons will be drawn on Ambient Display -->
    <dimen name="status_bar_icon_drawing_size_dark">@*android:dimen/notification_header_icon_size_ambient</dimen>

    <!-- opacity at which Notification icons will be drawn in the status bar -->
    <item type="dimen" name="status_bar_icon_drawing_alpha">90%</item>

    <!-- gap on either side of status bar notification icons -->
    <dimen name="status_bar_icon_padding">0dp</dimen>

    <!-- the padding on the start of the statusbar -->
    <dimen name="status_bar_padding_start">6dp</dimen>

    <!-- the padding on the end of the statusbar -->
    <dimen name="status_bar_padding_end">6dp</dimen>

    <!-- the radius of the overflow dot in the status bar -->
    <dimen name="overflow_dot_radius">2dp</dimen>

    <!-- the padding between dots in the icon overflow -->
    <dimen name="overflow_icon_dot_padding">3dp</dimen>

    <!-- The padding on the global screenshot background image -->
    <dimen name="global_screenshot_bg_padding">20dp</dimen>

    <!-- The width of the view containing navigation buttons -->
    <dimen name="navigation_key_width">70dp</dimen>

    <dimen name="navigation_key_padding">0dp</dimen>

    <!-- The width of the view containing the menu/ime navigation bar icons -->
    <dimen name="navigation_extra_key_width">36dp</dimen>

    <!-- The padding on the side of the navigation bar. Must be greater than or equal to
         navigation_extra_key_width -->
    <dimen name="navigation_side_padding">36dp</dimen>

    <!-- Default distance beyond which snaps to the matching target -->
    <dimen name="navbar_search_snap_margin">40dip</dimen>

    <!-- Diameter of outer shape drawable shown in navbar search-->
    <dimen name="navbar_search_outerring_diameter">340dp</dimen>

    <!-- Diameter of outer shape drawable shown in navbar search. Should be 1/2 of above value -->
    <dimen name="navbar_search_outerring_radius">170dp</dimen>

    <!-- Height of search panel including navigation bar height -->
    <dimen name="navbar_search_panel_height">230dip</dimen>

    <!-- Height of the draggable handle at the bottom of the phone notification panel -->
    <dimen name="close_handle_height">36dp</dimen>

    <!-- Amount of close_handle that will NOT overlap the notification list -->
    <dimen name="close_handle_underlap">32dp</dimen>

    <!-- Height of the status bar header bar in the car setting. -->
    <dimen name="car_status_bar_header_height">128dp</dimen>

    <!-- The bottom padding of the status bar header. -->
    <dimen name="status_bar_header_padding_bottom">48dp</dimen>

    <!-- The height of the container that holds the battery and time in the quick settings header.
         -->
    <dimen name="qs_header_system_icons_area_height">48dp</dimen>

    <!-- How far the quick-quick settings panel extends below the status bar -->
    <dimen name="qs_quick_header_panel_height">128dp</dimen>

    <!-- The height of the container that holds the system icons in the quick settings header in the
         car setting. -->
    <dimen name="car_qs_header_system_icons_area_height">54dp</dimen>

    <!-- The height of the quick settings footer that holds the user switcher, settings icon,
         etc. -->
    <dimen name="qs_footer_height">56dp</dimen>

    <!-- The padding between the notifications and the quick settings container -->
    <dimen name="qs_notification_padding">@dimen/notification_side_paddings</dimen>

    <!-- Height of the status bar header bar when expanded -->
    <dimen name="status_bar_header_height_expanded">124dp</dimen>

    <!-- Height of the status bar header bar when on Keyguard -->
    <dimen name="status_bar_header_height_keyguard">40dp</dimen>

    <!-- Margin start of the system icons super container -->
    <dimen name="system_icons_super_container_margin_start">16dp</dimen>

    <!-- Margin end of the system icons super container when the avatar is missing. -->
    <dimen name="system_icons_super_container_avatarless_margin_end">6dp</dimen>

    <!-- Width for the notification panel and related windows -->
    <dimen name="match_parent">-1px</dimen>
    <dimen name="standard_notification_panel_width">416dp</dimen>

    <!-- The top margin of the panel that holds the list of notifications. -->
    <dimen name="notification_panel_margin_top">0dp</dimen>

    <!-- The bottom margin of the panel that holds the list of notifications. -->
    <dimen name="notification_panel_margin_bottom">0dp</dimen>

    <dimen name="notification_panel_width">@dimen/match_parent</dimen>

    <dimen name="brightness_mirror_height">48dp</dimen>

    <!-- The width of the panel that holds the quick settings. -->
    <dimen name="qs_panel_width">@dimen/notification_panel_width</dimen>

    <dimen name="volume_dialog_panel_transparent_padding_right">8dp</dimen>

    <dimen name="volume_dialog_panel_transparent_padding">20dp</dimen>

    <dimen name="volume_dialog_stream_padding">8dp</dimen>

    <!-- the amount the volume panel should be offset at the end from the view next to it (or
    the screen edge, in portrait-->
    <dimen name="volume_dialog_base_margin">8dp</dimen>

    <dimen name="volume_dialog_panel_width">64dp</dimen>

    <dimen name="volume_dialog_slider_height">116dp</dimen>

    <dimen name="volume_dialog_row_height">252dp</dimen>

    <dimen name="volume_dialog_ringer_size">64dp</dimen>

    <dimen name="volume_dialog_tap_target_size">48dp</dimen>

    <dimen name="volume_dialog_spacer">4dp</dimen>

    <dimen name="volume_dialog_slider_margin_top">14dp</dimen>

    <dimen name="volume_dialog_slider_margin_bottom">-2dp</dimen>

    <dimen name="volume_dialog_row_margin_bottom">8dp</dimen>

    <dimen name="volume_dialog_settings_icon_size">16dp</dimen>

    <dimen name="volume_dialog_elevation">9dp</dimen>

    <!-- Gravity for the notification panel -->
    <integer name="notification_panel_layout_gravity">0x31</integer><!-- center_horizontal|top -->

    <!-- Height of the carrier/wifi name label -->
    <dimen name="carrier_label_height">24dp</dimen>

    <!-- The distance you can pull a notification before it pops open -->
    <dimen name="one_finger_pop_limit">0dp</dimen>

    <!-- Minimum fraction of the screen that should be taken up by the notification panel.
         Not used at this screen size. -->
    <item type="dimen" name="notification_panel_min_height_frac">0%</item>

    <dimen name="blinds_pop_threshold">0dp</dimen>

    <!-- The size of the gesture span needed to activate the "pull" notification expansion -->
    <dimen name="pull_span_min">25dp</dimen>

    <dimen name="qs_tile_height">106dp</dimen>
    <dimen name="qs_tile_layout_margin_side">6dp</dimen>
    <dimen name="qs_tile_margin_horizontal">18dp</dimen>
    <dimen name="qs_tile_margin_vertical">24dp</dimen>
    <dimen name="qs_tile_margin_top_bottom">12dp</dimen>
    <dimen name="qs_tile_margin_top">18dp</dimen>
    <dimen name="qs_quick_tile_size">48dp</dimen>
    <!-- Width for the spacer, used between QS tiles. -->
    <dimen name="qs_quick_tile_space_width">0dp</dimen>
    <dimen name="qs_quick_tile_padding">12dp</dimen>
    <dimen name="qs_header_gear_translation">16dp</dimen>
    <dimen name="qs_header_tile_margin_horizontal">0dp</dimen>
    <dimen name="qs_page_indicator_width">16dp</dimen>
    <dimen name="qs_page_indicator_height">8dp</dimen>
    <dimen name="qs_tile_icon_size">24dp</dimen>
    <dimen name="qs_tile_text_size">12sp</dimen>
    <dimen name="qs_tile_divider_height">1dp</dimen>
    <dimen name="qs_panel_padding">16dp</dimen>
    <dimen name="qs_dual_tile_height">112dp</dimen>
    <dimen name="qs_dual_tile_padding_vertical">8dp</dimen>
    <dimen name="qs_dual_tile_padding_horizontal">6dp</dimen>
    <dimen name="qs_tile_padding_top">14dp</dimen>
    <dimen name="qs_tile_padding_top_large_text">4dp</dimen>
    <dimen name="qs_tile_padding_below_icon">12dp</dimen>
    <dimen name="qs_tile_padding_bottom">16dp</dimen>
    <dimen name="qs_tile_spacing">4dp</dimen>
    <dimen name="qs_panel_padding_bottom">0dp</dimen>
    <dimen name="qs_panel_padding_top">30dp</dimen>
    <dimen name="qs_detail_header_height">56dp</dimen>
    <dimen name="qs_detail_header_padding">0dp</dimen>
    <dimen name="qs_detail_image_width">56dp</dimen>
    <dimen name="qs_detail_image_height">56dp</dimen>
    <dimen name="qs_detail_image_padding">16dp</dimen>
    <dimen name="qs_detail_item_height">48dp</dimen>
    <dimen name="qs_detail_header_text_size">20sp</dimen>
    <dimen name="qs_detail_button_text_size">14sp</dimen>
    <dimen name="qs_detail_item_primary_text_size">16sp</dimen>
    <dimen name="qs_detail_item_secondary_text_size">14sp</dimen>
    <dimen name="qs_detail_empty_text_size">14sp</dimen>
    <dimen name="qs_detail_margin_top">28dp</dimen>
    <dimen name="qs_detail_back_margin_end">16dp</dimen>
    <dimen name="qs_detail_header_text_padding">16dp</dimen>
    <dimen name="qs_data_usage_text_size">14sp</dimen>
    <dimen name="qs_data_usage_usage_text_size">36sp</dimen>
    <dimen name="qs_battery_padding">2dp</dimen>
    <dimen name="qs_detail_padding_start">16dp</dimen>
    <dimen name="qs_detail_items_padding_top">4dp</dimen>
    <dimen name="qs_detail_item_icon_size">24dp</dimen>
    <dimen name="qs_detail_item_icon_width">32dp</dimen>
    <dimen name="qs_detail_item_icon_marginStart">0dp</dimen>
    <dimen name="qs_detail_item_icon_marginEnd">20dp</dimen>
    <dimen name="qs_header_tooltip_height">18dp</dimen>
    <dimen name="qs_header_alarm_icon_size">18dp</dimen>
    <dimen name="qs_header_alarm_text_margin_start">6dp</dimen>
    <dimen name="qs_footer_padding_start">16dp</dimen>
    <dimen name="qs_footer_padding_end">16dp</dimen>
    <dimen name="qs_footer_icon_size">16dp</dimen>
    <dimen name="qs_paged_tile_layout_padding_bottom">24dp</dimen>

    <dimen name="qs_notif_collapsed_space">64dp</dimen>

    <!-- Desired qs icon overlay size. -->
    <dimen name="qs_detail_icon_overlay_size">24dp</dimen>

    <dimen name="segmented_button_spacing">0dp</dimen>
    <dimen name="borderless_button_radius">2dp</dimen>

    <dimen name="restricted_padlock_pading">4dp</dimen>

    <!-- How far the expanded QS panel peeks from the header in collapsed state. -->
    <dimen name="qs_peek_height">0dp</dimen>

    <!-- How large the icons in the quick settings footer dialog are -->
    <dimen name="qs_footer_dialog_icon_size">24sp</dimen>
    <!-- Left and right margin of the icons -->
    <dimen name="qs_footer_dialog_icon_margin">8sp</dimen>
    <!-- Padding between subtitles and the following text in the QSFooter dialog -->
    <dimen name="qs_footer_dialog_subtitle_padding">20dp</dimen>

    <dimen name="seek_bar_height">3dp</dimen>
    <dimen name="seek_bar_corner_radius">3dp</dimen>

    <!-- Zen mode panel: condition item button padding -->
    <dimen name="zen_mode_condition_detail_button_padding">8dp</dimen>

    <!-- Zen mode panel: spacing between condition items -->
    <dimen name="zen_mode_condition_detail_item_spacing">12dp</dimen>

    <!-- Zen mode panel: spacing between two-line condition upper and lower lines -->
    <dimen name="zen_mode_condition_detail_item_interline_spacing">4dp</dimen>

    <!-- Zen mode panel: bottom padding, a bit less than qs_panel_padding -->
    <dimen name="zen_mode_condition_detail_bottom_padding">4dp</dimen>

    <!-- used by DessertCase -->
    <dimen name="dessert_case_cell_size">192dp</dimen>

    <!-- Default glow radius for GlowPadView -->
    <dimen name="glowpadview_glow_radius">75dip</dimen>

    <!-- Default distance from each snap target that GlowPadView considers a "hit" -->
    <dimen name="glowpadview_inner_radius">15dip</dimen>

    <!-- Z distance between notifications if they are in the stack -->
    <dimen name="z_distance_between_notifications">0.5dp</dimen>

    <!-- The height of the divider between the individual notifications. -->
    <dimen name="notification_divider_height">0.5dp</dimen>

    <!-- The corner radius of the shadow behind the notification. -->
    <dimen name="notification_shadow_radius">0dp</dimen>

    <!-- The alpha of the dividing line between child notifications of a notification group. -->
    <item name="notification_divider_alpha" format="float" type="dimen">0.5</item>

    <!-- The height of the divider between the individual notifications in a notification
         group. -->
    <dimen name="notification_children_container_divider_height">@dimen/notification_divider_height</dimen>

    <!-- The top margin for the notification children container in its non-expanded form. -->
    <dimen name="notification_children_container_margin_top">@*android:dimen/notification_content_margin_top</dimen>

    <!-- The height of a notification header -->
    <dimen name="notification_header_height">53dp</dimen>

    <!-- The height of the divider between the individual notifications when the notification wants it to be increased. This is currently the case for notification groups -->
    <dimen name="notification_divider_height_increased">6dp</dimen>

    <!-- The minimum amount of top overscroll to go to the quick settings. -->
    <dimen name="min_top_overscroll_to_qs">36dp</dimen>

    <!-- The height of the speed bump view. -->
    <dimen name="speed_bump_height">16dp</dimen>

    <!-- Lockscreen unlocking falsing threshold. -->
    <dimen name="unlock_falsing_threshold">80dp</dimen>

    <!-- Lockscreen falsing threshold for quick settings. -->
    <dimen name="qs_falsing_threshold">60dp</dimen>

    <!-- Falsing threshold used when dismissing notifications from the lockscreen. -->
    <dimen name="swipe_helper_falsing_threshold">70dp</dimen>

    <!-- Minimum distance the user has to drag down to go to the full shade. -->
    <dimen name="keyguard_drag_down_min_distance">100dp</dimen>

    <!-- The margin between the clock and the notifications on Keyguard.-->
    <dimen name="keyguard_clock_notifications_margin">30dp</dimen>
    <!-- Minimum margin between clock and status bar -->
    <dimen name="keyguard_clock_top_margin">36dp</dimen>

    <item name="scrim_behind_alpha" format="float" type="dimen">0.62</item>

    <!-- The minimum amount the user needs to swipe to go to the camera / phone. -->
    <dimen name="keyguard_min_swipe_amount">110dp</dimen>

    <!-- The minimum background radius when swiping to a side for the camera / phone affordances. -->
    <dimen name="keyguard_affordance_min_background_radius">30dp</dimen>

    <!-- The size of the touch targets on the keyguard for the affordances. -->
    <dimen name="keyguard_affordance_touch_target_size">120dp</dimen>

    <!-- The grow amount for the camera and phone circles when hinting -->
    <dimen name="hint_grow_amount_sideways">60dp</dimen>

    <!-- Distance between notifications and header when they are considered to be colliding. -->
    <dimen name="header_notifications_collide_distance">48dp</dimen>

    <!-- Distance the user needs to drag vertically such that a swipe is accepted to unlock the
         device. -->
    <dimen name="unlock_move_distance">75dp</dimen>

    <!-- Move distance for the unlock hint animation on the lockscreen -->
    <dimen name="hint_move_distance">75dp</dimen>

    <!-- The width of the region on the left/right edge of the screen for performing the camera/
         phone hints. -->
    <dimen name="edge_tap_area_width">48dp</dimen>

    <!-- The padding between notification children when collapsed -->
    <dimen name="notification_children_padding">4dp</dimen>

    <!-- The padding on top of the first notification to the children container -->
    <dimen name="notification_children_container_top_padding">8dp</dimen>

    <!-- end margin for multi user switch in expanded quick settings -->
    <dimen name="multi_user_switch_expanded_margin">8dp</dimen>

    <!-- end margin for multi user switch in collapsed quick settings -->
    <dimen name="multi_user_switch_collapsed_margin">13dp</dimen>

    <!-- end margin for multi user switch in collapsed quick settings -->
    <dimen name="multi_user_switch_keyguard_margin">3dp</dimen>

    <!-- end margin for system icons if multi user switch is hidden -->
    <dimen name="system_icons_switcher_hidden_expanded_margin">16dp</dimen>

    <!-- The thickness of the colored border around the current user. -->
    <dimen name="keyguard_user_switcher_border_thickness">2dp</dimen>

    <dimen name="data_usage_graph_marker_width">4dp</dimen>

    <!-- The padding bottom of the clock group when QS is expanded. -->
    <dimen name="clock_expanded_bottom_margin">20dp</dimen>

    <!-- The padding bottom of the clock group when QS is collapsed. -->
    <dimen name="clock_collapsed_bottom_margin">10dp</dimen>

    <!-- The padding bottom of the clock group when QS is collapsed for large text -->
    <dimen name="clock_collapsed_bottom_margin_large_text">6dp</dimen>

    <!-- The width of the multi user switch on keyguard and collapsed QS header. -->
    <dimen name="multi_user_switch_width_collapsed">34dp</dimen>

    <!-- The width of the multi user switch in expanded QS header. -->
    <dimen name="multi_user_switch_width_expanded">48dp</dimen>

    <!-- The width of user avatar when on Keyguard -->
    <dimen name="multi_user_switch_width_keyguard">34dp</dimen>

    <!-- The width of user avatar when collapsed -->
    <dimen name="multi_user_avatar_collapsed_size">22dp</dimen>

    <!-- The width of user avatar when on Keyguard -->
    <dimen name="multi_user_avatar_keyguard_size">22dp</dimen>

    <!-- The width of user avatar when expanded -->
    <dimen name="multi_user_avatar_expanded_size">18dp</dimen>

    <!-- The font size of the time when collapsed in QS -->
    <dimen name="qs_time_collapsed_size">14sp</dimen>

    <!-- The font size of the time when expanded in QS -->
    <dimen name="qs_time_expanded_size">14sp</dimen>

    <!-- The font size of the "emergency calls only" label in QS -->
    <dimen name="qs_emergency_calls_only_text_size">12sp</dimen>

    <!-- The font size of the date in QS -->
    <dimen name="qs_date_collapsed_size">14sp</dimen>
    <!-- Amount the date/time move when emergency calls only is present -->
    <dimen name="qs_date_time_translation">8dp</dimen>

    <!-- Padding before battery level text in status bar, QS, and Keyguard -->
    <dimen name="battery_level_padding_start">4dp</dimen>

    <!-- The top padding of the clear all button -->
    <dimen name="clear_all_padding_top">12dp</dimen>

    <!-- Largest size an avatar might need to be drawn in the user picker, status bar, or
         quick settings header -->
    <dimen name="max_avatar_size">48dp</dimen>

    <!-- Size of user icon + frame in the qs/keyguard user picker (incl. frame) -->
    <dimen name="framed_avatar_size">54dp</dimen>

    <!-- Margin on the left side of the carrier text on Keyguard -->
    <dimen name="keyguard_carrier_text_margin">16dp</dimen>

    <!-- Margin on the left side of the battery % in the header. -->
    <dimen name="header_battery_margin_expanded">6dp</dimen>

    <!-- Margin on the left side of the battery % when on Keyguard. -->
    <dimen name="header_battery_margin_keyguard">6dp</dimen>

    <!-- Margin on the right side of the system icon group on Keyguard. -->
    <dimen name="system_icons_keyguard_padding_end">4dp</dimen>

    <!-- Additional translation (downwards) for appearing notifications when going to the full shade
         from Keyguard. -->
    <dimen name="go_to_full_shade_appearing_translation">200dp</dimen>

    <!-- The diameter of the search panel circle. -->
    <dimen name="assist_orb_size">144dp</dimen>

    <!-- The margin to the edge of the screen from where the orb starts to appear -->
    <dimen name="assist_orb_base_margin">22dp</dimen>

    <!-- The amount the orb translates when appearing -->
    <dimen name="assist_orb_travel_distance">26dp</dimen>

    <!-- The elevation of the orb -->
    <dimen name="assist_orb_elevation">12dp</dimen>

    <!-- The height of the scrim behind the orb. -->
    <dimen name="assist_orb_scrim_height">250dp</dimen>

    <!-- The height of the scrim behind the search panel circle. Should be navigation_bar_height
         + 8dp. -->
    <dimen name="assist_orb_navbar_scrim_height">56dp</dimen>

    <!-- The width/height of the phone/camera/unlock icon view on keyguard. -->
    <dimen name="keyguard_affordance_height">56dp</dimen>
    <dimen name="keyguard_affordance_width">56dp</dimen>

    <!-- The width/height of the phone/camera/unlock icon drawable on keyguard. -->
    <dimen name="keyguard_affordance_icon_height">24dp</dimen>
    <dimen name="keyguard_affordance_icon_width">24dp</dimen>

    <dimen name="keyguard_indication_margin_bottom">65dp</dimen>
    <dimen name="keyguard_indication_margin_bottom_ambient">16dp</dimen>

    <!-- The text size for battery level -->
    <dimen name="battery_level_text_size">12sp</dimen>

    <!-- TrustDrawable: Minimum inner radius of the breathing animation -->
    <dimen name="trust_circle_inner_radius_visible_min">22dp</dimen>
    <!-- TrustDrawable: Maximum inner radius of the breathing animation -->
    <dimen name="trust_circle_inner_radius_visible_max">24dp</dimen>
    <!-- TrustDrawable: Inner radius at the end of the exit animation -->
    <dimen name="trust_circle_inner_radius_exit">38dp</dimen>
    <!-- TrustDrawable: Inner radius at the beginning of the enter animation -->
    <dimen name="trust_circle_inner_radius_enter">18dp</dimen>
    <!-- TrustDrawable: Thickness of the circle -->
    <dimen name="trust_circle_thickness">2dp</dimen>

    <!-- How much two taps can be apart to still be recognized as a double tap on the lockscreen -->
    <dimen name="double_tap_slop">32dp</dimen>

    <dimen name="battery_margin_bottom">0dp</dimen>

    <!-- Padding at the end of the view that displays the mobile signal icons. If the view is
         empty, then this padding will not be added to that view. -->
    <dimen name="mobile_signal_group_end_padding">0dp</dimen>

    <!-- Padding between the mobile data type and the strength indicator. -->
    <dimen name="mobile_data_icon_start_padding">0dp</dimen>

    <!-- Extra padding between the mobile data type icon and the strength indicator when the data
         type icon is wide. -->
    <dimen name="wide_type_icon_start_padding">2dp</dimen>

    <!-- Padding between the mobile signal indicator and the start icon when the roaming icon
         is displayed in the upper left corner. -->
    <dimen name="roaming_icon_start_padding">2dp</dimen>

    <!-- Extra padding between multiple phone signal icons. -->
    <dimen name="secondary_telephony_padding">2dp</dimen>

    <!-- Extra padding between the mobile data type icon and the strength indicator when the data
         type icon is wide for the tile in quick settings. -->
    <dimen name="wide_type_icon_start_padding_qs">3dp</dimen>

    <dimen name="signal_indicator_to_icon_frame_spacing">3dp</dimen>

    <!-- The maximum width of the navigation bar ripples. -->
    <dimen name="key_button_ripple_max_width">95dp</dimen>

    <!-- Inset shadow for FakeShadowDrawable. It is used to avoid gaps between the card
         and the shadow. -->
    <dimen name="fake_shadow_inset">1dp</dimen>

    <dimen name="fake_shadow_size">8dp</dimen>

    <!-- Starting margin before the signal cluster -->
    <dimen name="signal_cluster_margin_start">2.5dp</dimen>

    <!-- Padding between signal cluster and battery icon -->
    <dimen name="signal_cluster_battery_padding">6dp</dimen>

    <!-- Padding for signal cluster and battery icon when there are not icons in signal cluster -->
    <dimen name="no_signal_cluster_battery_padding">3dp</dimen>

    <!-- Screen pinning request width -->
    <dimen name="screen_pinning_request_width">@dimen/match_parent</dimen>
    <!-- Screen pinning request nav button circle heights -->
    <dimen name="screen_pinning_request_button_height">66dp</dimen>
    <!-- Screen pinning request nav button circle widths -->
    <dimen name="screen_pinning_request_button_width">84dp</dimen>
    <!-- Screen pinning request padding on top of inner circle -->
    <dimen name="screen_pinning_request_inner_padding">14dp</dimen>
    <!-- Screen pinning request seascape negative padding -->
    <dimen name="screen_pinning_request_seascape_padding_negative">-18dp</dimen>
    <!-- Screen pinning request seascape button offset -->
    <dimen name="screen_pinning_request_seascape_button_offset">-4dp</dimen>
    <!-- Screen pinning request padding on top of icons -->
    <dimen name="screen_pinning_request_nav_icon_padding">18dp</dimen>
    <!-- Screen pinning request padding on side of icons
         (makes the width match the nav bar)-->
    <dimen name="screen_pinning_request_nav_side_padding">7dp</dimen>
    <!-- Screen pinning request side views to match nav bar
         navigation_side_padding - 3 / 2 * (screen_pinning_request_button_width
                                                - navigation_key_width) -->
    <dimen name="screen_pinning_request_side_width">34dp</dimen>
    <!-- Screen pinning request controls padding on bigger screens -->
    <dimen name="screen_pinning_request_frame_padding">0dp</dimen>
    <!-- Screen pinning inner nav bar circle size -->
    <dimen name="screen_pinning_nav_highlight_size">56dp</dimen>
    <!-- Screen pinning inner nav bar outer circle size -->
    <dimen name="screen_pinning_nav_highlight_outer_size">84dp</dimen>

    <!-- Padding to be used on the bottom of the fingerprint icon on Keyguard so it better aligns
         with the other icons. -->
    <dimen name="fingerprint_icon_additional_padding">4dp</dimen>

    <!-- Minimum margin of the notification panel on the side, when being positioned dynamically -->
    <dimen name="notification_panel_min_side_margin">48dp</dimen>

    <!-- Vertical spacing between multiple volume slider rows -->
    <dimen name="volume_slider_interspacing">8dp</dimen>

    <!-- Volume dialog vertical offset from the top of the screen -->
    <dimen name="volume_offset_top">0dp</dimen>

    <!-- Standard image button size for volume dialog buttons -->
    <dimen name="volume_button_size">48dp</dimen>

    <!-- Volume dialog root view bottom margin, at rest -->
    <dimen name="volume_dialog_margin_bottom">4dp</dimen>
    <dimen name="volume_dialog_padding_top">8dp</dimen>
    <dimen name="volume_dialog_padding_end">40dp</dimen>

    <dimen name="volume_row_padding_bottom">9.4dp</dimen>
    <dimen name="volume_row_padding_start">4dp</dimen>
    <dimen name="volume_row_header_padding_start">16dp</dimen>
    <dimen name="volume_row_height">64dp</dimen>
    <dimen name="volume_row_slider_height">48dp</dimen>
    <dimen name="volume_row_slider_padding_start">12dp</dimen>

    <dimen name="volume_expander_margin_end">2dp</dimen>
    <dimen name="volume_expander_margin_top">6dp</dimen>

    <!-- Thickness of the assist disclosure beams -->
    <dimen name="assist_disclosure_thickness">2.5dp</dimen>

    <!-- Thickness of the shadows of the assist disclosure beams -->
    <dimen name="assist_disclosure_shadow_thickness">1.5dp</dimen>

    <dimen name="fab_size">56dp</dimen>
    <dimen name="fab_margin">16dp</dimen>
    <dimen name="fab_elevation">12dp</dimen>
    <dimen name="fab_press_translation_z">9dp</dimen>

    <!-- How high we lift the divider when touching -->
    <dimen name="docked_stack_divider_lift_elevation">4dp</dimen>

    <dimen name="docked_divider_handle_width">16dp</dimen>
    <dimen name="docked_divider_handle_height">2dp</dimen>

    <dimen name="battery_detail_graph_space_top">27dp</dimen>
    <dimen name="battery_detail_graph_space_bottom">27dp</dimen>

    <!-- Keyboard shortcuts helper -->
    <dimen name="ksh_layout_width">@dimen/match_parent</dimen>
    <dimen name="ksh_item_text_size">14sp</dimen>
    <dimen name="ksh_item_padding">4dp</dimen>
    <dimen name="ksh_item_margin_start">4dp</dimen>

<!-- Recents Layout -->

    <!-- The amount to inset the stack, specifically at the top and the other sides.  We also
         don't want this to change across configurations that Recents can be opened in, so we
         define them statically for all display sizes. -->
    <dimen name="recents_layout_min_margin">16dp</dimen>
    <dimen name="recents_layout_top_margin_phone">16dp</dimen>
    <dimen name="recents_layout_top_margin_tablet">32dp</dimen>
    <dimen name="recents_layout_top_margin_tablet_xlarge">40dp</dimen>
    <dimen name="recents_layout_bottom_margin">16dp</dimen>
    <dimen name="recents_layout_side_margin_phone">16dp</dimen>
    <dimen name="recents_layout_side_margin_tablet">48dp</dimen>
    <dimen name="recents_layout_side_margin_tablet_docked">16dp</dimen>
    <dimen name="recents_layout_side_margin_tablet_xlarge">64dp</dimen>
    <dimen name="recents_layout_side_margin_tablet_xlarge_docked">16dp</dimen>

    <!-- The height between the top margin and the top of the focused task. -->
    <dimen name="recents_layout_top_peek_size">48dp</dimen>
    <!-- The height between the bottom margin and the top of task in front of the focused task. -->
    <dimen name="recents_layout_bottom_peek_size">56dp</dimen>

    <!-- The offset from the top and bottom of the stack of the focused task.  The bottom offset
         will be additionally offset by the bottom system insets since it goes under the nav bar
         in certain orientations. -->
    <dimen name="recents_layout_initial_top_offset_phone_port">128dp</dimen>
    <dimen name="recents_layout_initial_bottom_offset_phone_port">80dp</dimen>
    <dimen name="recents_layout_initial_top_offset_phone_land">72dp</dimen>
    <dimen name="recents_layout_initial_bottom_offset_phone_land">72dp</dimen>
    <dimen name="recents_layout_initial_top_offset_tablet">160dp</dimen>
    <dimen name="recents_layout_initial_bottom_offset_tablet">112dp</dimen>

    <!-- The min/max translationZ for the tasks in the stack. -->
    <dimen name="recents_layout_z_min">3dp</dimen>
    <dimen name="recents_layout_z_max">24dp</dimen>

    <!-- The margin between the freeform and stack.  We also don't want this to change across
         configurations that Recents can be opened in, so we define them statically for all
         display sizes. -->
    <dimen name="recents_freeform_layout_bottom_margin">16dp</dimen>

    <!-- The padding between each freeform task. -->
    <dimen name="recents_freeform_layout_task_padding">8dp</dimen>

<!-- Recents Views -->

    <!-- The height of a task view bar.  This has to be large enough to cover the action bar
         height in either orientation at this smallest width. -->
    <dimen name="recents_task_view_header_height">56dp</dimen>
    <dimen name="recents_task_view_header_height_tablet_land">64dp</dimen>

    <!-- The padding of a button in the recents task view header. -->
    <dimen name="recents_task_view_header_button_padding">16dp</dimen>
    <dimen name="recents_task_view_header_button_padding_tablet_land">20dp</dimen>

    <!-- The radius of the rounded corners on a task view and its shadow (which can be larger
         to create a softer corner effect. -->
    <dimen name="recents_task_view_rounded_corners_radius">2dp</dimen>
    <dimen name="recents_task_view_shadow_rounded_corners_radius">6dp</dimen>

    <!-- The amount of highlight to make on each task view. -->
    <dimen name="recents_task_view_highlight">1dp</dimen>

    <!-- The size of the lock-to-app button and its icon. -->
    <dimen name="recents_lock_to_app_size">56dp</dimen>
    <dimen name="recents_lock_to_app_icon_size">28dp</dimen>

    <!-- The amount of overscroll allowed when flinging to the end of the stack. -->
    <dimen name="recents_fling_overscroll_distance">24dp</dimen>

    <!-- The size of the drag hint text. -->
    <dimen name="recents_drag_hint_text_size">14sp</dimen>

    <!-- The size of corner radius of the arrow in the onboarding toast. -->
    <dimen name="recents_onboarding_toast_arrow_corner_radius">2dp</dimen>
    <!-- The start margin of quick scrub onboarding toast. -->
    <dimen name="recents_quick_scrub_onboarding_margin_start">8dp</dimen>

    <!-- The min alpha to apply to a task affiliation group color. -->
    <item name="recents_task_affiliation_color_min_alpha_percentage" format="float" type="dimen">0.6</item>

    <!-- The amount to offset when animating into an affiliate group. -->
    <dimen name="recents_task_stack_animation_affiliate_enter_offset">32dp</dimen>

    <!-- The offsets the tasks animate from when recents is launched while docking -->
    <dimen name="recents_task_stack_animation_launched_while_docking_offset">144dp</dimen>

    <!-- The amount to translate when animating the removal of a task. -->
    <dimen name="recents_task_view_remove_anim_translation_x">100dp</dimen>

    <!-- The alpha to apply to the recents row when it doesn't have focus -->
    <item name="recents_recents_row_dim_alpha" format="float" type="dimen">0.5</item>

    <!-- The speed in dp/s at which the user needs to be scrolling in recents such that we start
         loading full resolution screenshots. -->
    <dimen name="recents_fast_fling_velocity">600dp</dimen>

    <!-- The height of the gradient indicating the dismiss edge when moving a PIP. -->
    <dimen name="pip_dismiss_gradient_height">176dp</dimen>

    <!-- The bottom margin of the PIP drag to dismiss info text shown when moving a PIP. -->
    <dimen name="pip_dismiss_text_bottom_margin">24dp</dimen>

    <!-- The shortest-edge size of the expanded PiP. -->
    <dimen name="pip_expanded_shortest_edge_size">160dp</dimen>

    <!-- The additional offset to apply to the IME animation to account for the input field. -->
    <dimen name="pip_ime_offset">48dp</dimen>

    <!-- The padding between actions in the PiP in landscape  Note that the PiP does not reflect
         the configuration of the device, so we can't use -land resources. -->
    <dimen name="pip_between_action_padding_land">8dp</dimen>

    <!-- The height of the PiP actions container in which the actions are vertically centered. -->
    <dimen name="pip_action_size">48dp</dimen>

    <!-- The padding around a PiP actions. -->
    <dimen name="pip_action_padding">12dp</dimen>

    <!-- The bottom margin of the expand container when there are actions.
         Equal to pip_action_size - pip_action_padding. -->
    <dimen name="pip_expand_container_edge_margin">30dp</dimen>

    <dimen name="default_gear_space">18dp</dimen>
    <dimen name="cell_overlay_padding">18dp</dimen>

    <dimen name="global_actions_panel_width">120dp</dimen>

    <dimen name="global_actions_top_padding">120dp</dimen>

    <dimen name="global_actions_padding">12dp</dimen>

    <dimen name="global_actions_translate">9dp</dimen>

    <!-- The maximum offset in either direction that elements are moved horizontally to prevent
         burn-in on AOD. -->
    <dimen name="burn_in_prevention_offset_x">8dp</dimen>

    <!-- The maximum offset in either direction that elements are moved vertically to prevent
         burn-in on AOD. -->
    <dimen name="burn_in_prevention_offset_y">50dp</dimen>

    <!-- The maximum offset in either direction that the charging indication moves vertically
         to prevent burn-in on AOD. -->
    <dimen name="charging_indication_burn_in_prevention_offset_y">5dp</dimen>

    <dimen name="corner_size">8dp</dimen>
    <dimen name="top_padding">0dp</dimen>
    <dimen name="bottom_padding">48dp</dimen>
    <dimen name="edge_margin">8dp</dimen>

    <dimen name="rounded_corner_radius">@*android:dimen/rounded_corner_radius</dimen>
    <dimen name="rounded_corner_radius_top">@*android:dimen/rounded_corner_radius_top</dimen>
    <dimen name="rounded_corner_radius_bottom">@*android:dimen/rounded_corner_radius_bottom</dimen>
    <dimen name="rounded_corner_content_padding">0dp</dimen>
    <dimen name="nav_content_padding">0dp</dimen>
    <dimen name="nav_quick_scrub_track_edge_padding">24dp</dimen>
    <dimen name="nav_quick_scrub_track_thickness">10dp</dimen>

    <!-- Navigation bar shadow params. -->
    <dimen name="nav_key_button_shadow_offset_x">0dp</dimen>
    <dimen name="nav_key_button_shadow_offset_y">1dp</dimen>
    <dimen name="nav_key_button_shadow_radius">0.5dp</dimen>

    <!-- Smart reply button. Total height 48dp, visible height 32dp. -->
    <dimen name="smart_reply_button_spacing">8dp</dimen>
    <dimen name="smart_reply_button_padding_vertical">14dp</dimen>
    <!-- Note: The following two paddings need to be different until b/78876518 is fixed. -->
    <dimen name="smart_reply_button_padding_horizontal_single_line">20dp</dimen>
    <dimen name="smart_reply_button_padding_horizontal_double_line">19dp</dimen>
    <dimen name="smart_reply_button_min_height">48dp</dimen>
    <dimen name="smart_reply_button_stroke_width">1dp</dimen>
    <dimen name="smart_reply_button_font_size">14sp</dimen>
    <dimen name="smart_reply_button_line_spacing_extra">6sp</dimen> <!-- Total line height 20sp. -->

    <!-- A reasonable upper bound for the height of the smart reply button. The measuring code
            needs to start with a guess for the maximum size. Currently two-line smart reply buttons
            add about 88dp of height to the notifications. -->
    <dimen name="smart_reply_button_max_height">100dp</dimen>

    <!-- The extra height that we allow a notification with a remote input history to be taller than
         the regular notification, when we have remote input history texts present. -->
    <dimen name="remote_input_history_extra_height">60dp</dimen>

    <!-- Fingerprint Dialog values -->
    <dimen name="fingerprint_dialog_fp_icon_size">64dp</dimen>
    <dimen name="fingerprint_dialog_animation_translation_offset">350dp</dimen>
    <dimen name="fingerprint_dialog_corner_size">4dp</dimen>

    <!-- Wireless Charging Animation values -->
    <dimen name="wireless_charging_dots_radius_start">0dp</dimen>
    <dimen name="wireless_charging_dots_radius_end">4dp</dimen>
    <dimen name="wireless_charging_circle_radius_start">28dp</dimen>
    <dimen name="wireless_charging_circle_radius_end">84dp</dimen>
    <integer name="wireless_charging_angle_offset">20</integer>
    <integer name="wireless_charging_scale_dots_duration">83</integer>
    <integer name="wireless_charging_num_dots">16</integer>
    <!-- Starting text size in sp of batteryLevel for wireless charging animation -->
    <item name="wireless_charging_anim_battery_level_text_size_start" format="float" type="dimen">0</item>
    <!-- Ending text size in sp of batteryLevel for wireless charging animation -->
    <item name="wireless_charging_anim_battery_level_text_size_end" format="float" type="dimen">24</item>
    <!-- time until battery info is at full opacity-->
    <integer name="wireless_charging_anim_opacity_offset">80</integer>
    <!-- duration batteryLevel opacity goes from 0 to 1 duration -->
    <integer name="wireless_charging_battery_level_text_opacity_duration">117</integer>
    <!-- battery text scale animation duration -->
    <integer name="wireless_charging_battery_level_text_scale_animation_duration">367</integer>
    <!--time until wireless charging animation starts to fade-->
    <integer name="wireless_charging_fade_offset">920</integer>
    <!-- duration wireless charging animation takes to full fade to 0 opacity -->
    <integer name="wireless_charging_fade_duration">200</integer>

    <!-- Wired charging on AOD, text animation duration -->
    <integer name="wired_charging_keyguard_text_animation_duration_down">500</integer>
    <!-- Wired charging on AOD, text animation duration -->
    <integer name="wired_charging_keyguard_text_animation_duration_up">300</integer>
    <!-- Wired charging on AOD, text animation distance -->
    <integer name="wired_charging_keyguard_text_animation_distance">-30</integer>

    <!-- Logout button -->
    <dimen name="logout_button_layout_height">32dp</dimen>
    <dimen name="logout_button_padding_horizontal">16dp</dimen>
    <dimen name="logout_button_margin_bottom">12dp</dimen>
    <dimen name="logout_button_corner_radius">2dp</dimen>

    <!-- How much into a DisplayCutout's bounds we can go, on each side -->
    <dimen name="display_cutout_margin_consumption">0px</dimen>

    <!-- How much we expand the touchable region of the status bar below the notch to catch touches
         that just start below the notch. -->
    <dimen name="display_cutout_touchable_region_size">12dp</dimen>
</resources>
