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