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