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