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