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