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