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