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