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