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