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