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