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