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