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