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