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