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