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