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