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