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