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