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