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