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