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