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