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