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