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