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